This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Integrate change #9108 from maintperl to mainline.
[perl5.git] / op.c
CommitLineData
a0d0e21e 1/* op.c
79072805 2 *
bc89e66f 3 * Copyright (c) 1991-2001, 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 24
1c846c1f 25#ifdef PL_OP_SLAB_ALLOC
b7dc083c
NIS
26#define SLAB_SIZE 8192
27static char *PL_OpPtr = NULL;
28static int PL_OpSpace = 0;
29#define NewOp(m,var,c,type) do { if ((PL_OpSpace -= c*sizeof(type)) >= 0) \
30 var = (type *)(PL_OpPtr -= c*sizeof(type)); \
31 else \
32 var = (type *) Slab_Alloc(m,c*sizeof(type)); \
33 } while (0)
34
1c846c1f 35STATIC void *
cea2e8a9 36S_Slab_Alloc(pTHX_ int m, size_t sz)
1c846c1f 37{
b7dc083c
NIS
38 Newz(m,PL_OpPtr,SLAB_SIZE,char);
39 PL_OpSpace = SLAB_SIZE - sz;
40 return PL_OpPtr += PL_OpSpace;
41}
76e3520e 42
1c846c1f 43#else
b7dc083c
NIS
44#define NewOp(m, var, c, type) Newz(m, var, c, type)
45#endif
e50aee73 46/*
5dc0d613 47 * In the following definition, the ", Nullop" is just to make the compiler
a5f75d66 48 * think the expression is of the right type: croak actually does a Siglongjmp.
e50aee73 49 */
11343788 50#define CHECKOP(type,o) \
3280af22 51 ((PL_op_mask && PL_op_mask[type]) \
5dc0d613 52 ? ( op_free((OP*)o), \
cea2e8a9 53 Perl_croak(aTHX_ "%s trapped by operation mask", PL_op_desc[type]), \
28757baa 54 Nullop ) \
fc0dc3b3 55 : CALL_FPTR(PL_check[type])(aTHX_ (OP*)o))
e50aee73 56
c53d7c7d 57#define PAD_MAX 999999999
e6438c1a 58#define RETURN_UNLIMITED_NUMBER (PERL_INT_MAX / 2)
c53d7c7d 59
76e3520e 60STATIC char*
cea2e8a9 61S_gv_ename(pTHX_ GV *gv)
4633a7c4 62{
2d8e6c8d 63 STRLEN n_a;
4633a7c4 64 SV* tmpsv = sv_newmortal();
46fc3d4c 65 gv_efullname3(tmpsv, gv, Nullch);
2d8e6c8d 66 return SvPV(tmpsv,n_a);
4633a7c4
LW
67}
68
76e3520e 69STATIC OP *
cea2e8a9 70S_no_fh_allowed(pTHX_ OP *o)
79072805 71{
cea2e8a9 72 yyerror(Perl_form(aTHX_ "Missing comma after first argument to %s function",
22c35a8c 73 PL_op_desc[o->op_type]));
11343788 74 return o;
79072805
LW
75}
76
76e3520e 77STATIC OP *
cea2e8a9 78S_too_few_arguments(pTHX_ OP *o, char *name)
79072805 79{
cea2e8a9 80 yyerror(Perl_form(aTHX_ "Not enough arguments for %s", name));
11343788 81 return o;
79072805
LW
82}
83
76e3520e 84STATIC OP *
cea2e8a9 85S_too_many_arguments(pTHX_ OP *o, char *name)
79072805 86{
cea2e8a9 87 yyerror(Perl_form(aTHX_ "Too many arguments for %s", name));
11343788 88 return o;
79072805
LW
89}
90
76e3520e 91STATIC void
cea2e8a9 92S_bad_type(pTHX_ I32 n, char *t, char *name, OP *kid)
8990e307 93{
cea2e8a9 94 yyerror(Perl_form(aTHX_ "Type of arg %d to %s must be %s (not %s)",
22c35a8c 95 (int)n, name, t, PL_op_desc[kid->op_type]));
8990e307
LW
96}
97
7a52d87a 98STATIC void
cea2e8a9 99S_no_bareword_allowed(pTHX_ OP *o)
7a52d87a 100{
5a844595
GS
101 qerror(Perl_mess(aTHX_
102 "Bareword \"%s\" not allowed while \"strict subs\" in use",
7766f137 103 SvPV_nolen(cSVOPo_sv)));
7a52d87a
GS
104}
105
9b877dbb
IH
106STATIC U8*
107S_trlist_upgrade(pTHX_ U8** sp, U8** ep)
108{
109 U8 *s = *sp;
110 U8 *e = *ep;
111 U8 *d;
112
113 Newz(801, d, (e - s) * 2, U8);
114 *sp = d;
115
116 while (s < e) {
117 if (*s < 0x80 || *s == 0xff)
118 *d++ = *s++;
119 else {
120 U8 c = *s++;
121 *d++ = ((c >> 6) | 0xc0);
122 *d++ = ((c & 0x3f) | 0x80);
123 }
124 }
125 *ep = d;
126 return *sp;
127}
9041c2e3 128
9b877dbb 129
79072805
LW
130/* "register" allocation */
131
132PADOFFSET
864dbfa3 133Perl_pad_allocmy(pTHX_ char *name)
93a17b20 134{
a0d0e21e
LW
135 PADOFFSET off;
136 SV *sv;
137
155aba94
GS
138 if (!(PL_in_my == KEY_our ||
139 isALPHA(name[1]) ||
fd400ab9 140 (PL_hints & HINT_UTF8 && UTF8_IS_START(name[1])) ||
155aba94 141 (name[1] == '_' && (int)strlen(name) > 2)))
834a4ddd 142 {
c4d0567e 143 if (!isPRINT(name[1]) || strchr("\t\n\r\f", name[1])) {
2b92dfce
GS
144 /* 1999-02-27 mjd@plover.com */
145 char *p;
146 p = strchr(name, '\0');
147 /* The next block assumes the buffer is at least 205 chars
148 long. At present, it's always at least 256 chars. */
149 if (p-name > 200) {
150 strcpy(name+200, "...");
151 p = name+199;
152 }
153 else {
154 p[1] = '\0';
155 }
156 /* Move everything else down one character */
157 for (; p-name > 2; p--)
158 *p = *(p-1);
46fc3d4c
PP
159 name[2] = toCTRL(name[1]);
160 name[1] = '^';
161 }
cea2e8a9 162 yyerror(Perl_form(aTHX_ "Can't use global %s in \"my\"",name));
a0d0e21e 163 }
e476b1b5 164 if (ckWARN(WARN_MISC) && AvFILLp(PL_comppad_name) >= 0) {
3280af22 165 SV **svp = AvARRAY(PL_comppad_name);
33633739
GS
166 HV *ourstash = (PL_curstash ? PL_curstash : PL_defstash);
167 PADOFFSET top = AvFILLp(PL_comppad_name);
168 for (off = top; off > PL_comppad_name_floor; off--) {
b1cb66bf 169 if ((sv = svp[off])
3280af22 170 && sv != &PL_sv_undef
c53d7c7d 171 && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0)
33633739
GS
172 && (PL_in_my != KEY_our
173 || ((SvFLAGS(sv) & SVpad_OUR) && GvSTASH(sv) == ourstash))
b1cb66bf
PP
174 && strEQ(name, SvPVX(sv)))
175 {
e476b1b5 176 Perl_warner(aTHX_ WARN_MISC,
1c846c1f 177 "\"%s\" variable %s masks earlier declaration in same %s",
33633739
GS
178 (PL_in_my == KEY_our ? "our" : "my"),
179 name,
180 (SvIVX(sv) == PAD_MAX ? "scope" : "statement"));
181 --off;
182 break;
183 }
184 }
185 if (PL_in_my == KEY_our) {
635bab04 186 do {
33633739
GS
187 if ((sv = svp[off])
188 && sv != &PL_sv_undef
5ce0178e 189 && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0)
33633739
GS
190 && ((SvFLAGS(sv) & SVpad_OUR) && GvSTASH(sv) == ourstash)
191 && strEQ(name, SvPVX(sv)))
f472eb5c 192 {
e476b1b5 193 Perl_warner(aTHX_ WARN_MISC,
33633739 194 "\"our\" variable %s redeclared", name);
e476b1b5 195 Perl_warner(aTHX_ WARN_MISC,
cc507455 196 "\t(Did you mean \"local\" instead of \"our\"?)\n");
33633739 197 break;
f472eb5c 198 }
635bab04 199 } while ( off-- > 0 );
b1cb66bf
PP
200 }
201 }
a0d0e21e
LW
202 off = pad_alloc(OP_PADSV, SVs_PADMY);
203 sv = NEWSV(1102,0);
93a17b20
LW
204 sv_upgrade(sv, SVt_PVNV);
205 sv_setpv(sv, name);
3280af22 206 if (PL_in_my_stash) {
c750a3ec 207 if (*name != '$')
eb64745e
GS
208 yyerror(Perl_form(aTHX_ "Can't declare class for non-scalar %s in \"%s\"",
209 name, PL_in_my == KEY_our ? "our" : "my"));
c750a3ec
MB
210 SvOBJECT_on(sv);
211 (void)SvUPGRADE(sv, SVt_PVMG);
3280af22
NIS
212 SvSTASH(sv) = (HV*)SvREFCNT_inc(PL_in_my_stash);
213 PL_sv_objcount++;
c750a3ec 214 }
f472eb5c
GS
215 if (PL_in_my == KEY_our) {
216 (void)SvUPGRADE(sv, SVt_PVGV);
ef75a179 217 GvSTASH(sv) = (HV*)SvREFCNT_inc(PL_curstash ? (SV*)PL_curstash : (SV*)PL_defstash);
77ca0c92 218 SvFLAGS(sv) |= SVpad_OUR;
f472eb5c 219 }
3280af22 220 av_store(PL_comppad_name, off, sv);
65202027 221 SvNVX(sv) = (NV)PAD_MAX;
8990e307 222 SvIVX(sv) = 0; /* Not yet introduced--see newSTATEOP */
3280af22
NIS
223 if (!PL_min_intro_pending)
224 PL_min_intro_pending = off;
225 PL_max_intro_pending = off;
93a17b20 226 if (*name == '@')
3280af22 227 av_store(PL_comppad, off, (SV*)newAV());
93a17b20 228 else if (*name == '%')
3280af22
NIS
229 av_store(PL_comppad, off, (SV*)newHV());
230 SvPADMY_on(PL_curpad[off]);
93a17b20
LW
231 return off;
232}
233
94f23f41
GS
234STATIC PADOFFSET
235S_pad_addlex(pTHX_ SV *proto_namesv)
236{
237 SV *namesv = NEWSV(1103,0);
238 PADOFFSET newoff = pad_alloc(OP_PADSV, SVs_PADMY);
239 sv_upgrade(namesv, SVt_PVNV);
240 sv_setpv(namesv, SvPVX(proto_namesv));
241 av_store(PL_comppad_name, newoff, namesv);
242 SvNVX(namesv) = (NV)PL_curcop->cop_seq;
243 SvIVX(namesv) = PAD_MAX; /* A ref, intro immediately */
244 SvFAKE_on(namesv); /* A ref, not a real var */
245 if (SvFLAGS(proto_namesv) & SVpad_OUR) { /* An "our" variable */
246 SvFLAGS(namesv) |= SVpad_OUR;
247 (void)SvUPGRADE(namesv, SVt_PVGV);
248 GvSTASH(namesv) = (HV*)SvREFCNT_inc((SV*)GvSTASH(proto_namesv));
249 }
250 if (SvOBJECT(proto_namesv)) { /* A typed var */
251 SvOBJECT_on(namesv);
252 (void)SvUPGRADE(namesv, SVt_PVMG);
253 SvSTASH(namesv) = (HV*)SvREFCNT_inc((SV*)SvSTASH(proto_namesv));
254 PL_sv_objcount++;
255 }
256 return newoff;
257}
258
2680586e
GS
259#define FINDLEX_NOSEARCH 1 /* don't search outer contexts */
260
76e3520e 261STATIC PADOFFSET
cea2e8a9 262S_pad_findlex(pTHX_ char *name, PADOFFSET newoff, U32 seq, CV* startcv,
864dbfa3 263 I32 cx_ix, I32 saweval, U32 flags)
93a17b20 264{
748a9306 265 CV *cv;
93a17b20
LW
266 I32 off;
267 SV *sv;
93a17b20 268 register I32 i;
c09156bb 269 register PERL_CONTEXT *cx;
93a17b20 270
748a9306 271 for (cv = startcv; cv; cv = CvOUTSIDE(cv)) {
4fdae800
PP
272 AV *curlist = CvPADLIST(cv);
273 SV **svp = av_fetch(curlist, 0, FALSE);
748a9306 274 AV *curname;
4fdae800 275
3280af22 276 if (!svp || *svp == &PL_sv_undef)
4633a7c4 277 continue;
748a9306
LW
278 curname = (AV*)*svp;
279 svp = AvARRAY(curname);
93965878 280 for (off = AvFILLp(curname); off > 0; off--) {
748a9306 281 if ((sv = svp[off]) &&
3280af22 282 sv != &PL_sv_undef &&
748a9306 283 seq <= SvIVX(sv) &&
13826f2c 284 seq > I_32(SvNVX(sv)) &&
748a9306
LW
285 strEQ(SvPVX(sv), name))
286 {
5f05dabc
PP
287 I32 depth;
288 AV *oldpad;
289 SV *oldsv;
290
291 depth = CvDEPTH(cv);
292 if (!depth) {
9607fc9c
PP
293 if (newoff) {
294 if (SvFAKE(sv))
295 continue;
4fdae800 296 return 0; /* don't clone from inactive stack frame */
9607fc9c 297 }
5f05dabc
PP
298 depth = 1;
299 }
94f23f41 300 oldpad = (AV*)AvARRAY(curlist)[depth];
5f05dabc 301 oldsv = *av_fetch(oldpad, off, TRUE);
748a9306 302 if (!newoff) { /* Not a mere clone operation. */
94f23f41 303 newoff = pad_addlex(sv);
3280af22 304 if (CvANON(PL_compcv) || SvTYPE(PL_compcv) == SVt_PVFM) {
28757baa 305 /* "It's closures all the way down." */
3280af22 306 CvCLONE_on(PL_compcv);
54310121 307 if (cv == startcv) {
3280af22 308 if (CvANON(PL_compcv))
54310121
PP
309 oldsv = Nullsv; /* no need to keep ref */
310 }
311 else {
28757baa
PP
312 CV *bcv;
313 for (bcv = startcv;
314 bcv && bcv != cv && !CvCLONE(bcv);
6b35e009
GS
315 bcv = CvOUTSIDE(bcv))
316 {
94f23f41
GS
317 if (CvANON(bcv)) {
318 /* install the missing pad entry in intervening
319 * nested subs and mark them cloneable.
320 * XXX fix pad_foo() to not use globals */
321 AV *ocomppad_name = PL_comppad_name;
322 AV *ocomppad = PL_comppad;
323 SV **ocurpad = PL_curpad;
324 AV *padlist = CvPADLIST(bcv);
325 PL_comppad_name = (AV*)AvARRAY(padlist)[0];
326 PL_comppad = (AV*)AvARRAY(padlist)[1];
327 PL_curpad = AvARRAY(PL_comppad);
328 pad_addlex(sv);
329 PL_comppad_name = ocomppad_name;
330 PL_comppad = ocomppad;
331 PL_curpad = ocurpad;
28757baa 332 CvCLONE_on(bcv);
94f23f41 333 }
28757baa 334 else {
6b35e009
GS
335 if (ckWARN(WARN_CLOSURE)
336 && !CvUNIQUE(bcv) && !CvUNIQUE(cv))
337 {
cea2e8a9 338 Perl_warner(aTHX_ WARN_CLOSURE,
44a8e56a 339 "Variable \"%s\" may be unavailable",
28757baa 340 name);
6b35e009 341 }
28757baa
PP
342 break;
343 }
344 }
345 }
346 }
3280af22 347 else if (!CvUNIQUE(PL_compcv)) {
741b6338
GS
348 if (ckWARN(WARN_CLOSURE) && !SvFAKE(sv) && !CvUNIQUE(cv)
349 && !(SvFLAGS(sv) & SVpad_OUR))
350 {
cea2e8a9 351 Perl_warner(aTHX_ WARN_CLOSURE,
599cee73 352 "Variable \"%s\" will not stay shared", name);
741b6338 353 }
5f05dabc 354 }
748a9306 355 }
3280af22 356 av_store(PL_comppad, newoff, SvREFCNT_inc(oldsv));
748a9306
LW
357 return newoff;
358 }
93a17b20
LW
359 }
360 }
361
2680586e
GS
362 if (flags & FINDLEX_NOSEARCH)
363 return 0;
364
93a17b20
LW
365 /* Nothing in current lexical context--try eval's context, if any.
366 * This is necessary to let the perldb get at lexically scoped variables.
367 * XXX This will also probably interact badly with eval tree caching.
368 */
369
748a9306 370 for (i = cx_ix; i >= 0; i--) {
93a17b20 371 cx = &cxstack[i];
6b35e009 372 switch (CxTYPE(cx)) {
93a17b20 373 default:
748a9306
LW
374 if (i == 0 && saweval) {
375 seq = cxstack[saweval].blk_oldcop->cop_seq;
2680586e 376 return pad_findlex(name, newoff, seq, PL_main_cv, -1, saweval, 0);
748a9306 377 }
93a17b20
LW
378 break;
379 case CXt_EVAL:
44a8e56a
PP
380 switch (cx->blk_eval.old_op_type) {
381 case OP_ENTEREVAL:
6b35e009
GS
382 if (CxREALEVAL(cx))
383 saweval = i;
44a8e56a 384 break;
faa7e5bb 385 case OP_DOFILE:
44a8e56a 386 case OP_REQUIRE:
faa7e5bb 387 /* require/do must have their own scope */
44a8e56a
PP
388 return 0;
389 }
93a17b20 390 break;
7766f137 391 case CXt_FORMAT:
93a17b20
LW
392 case CXt_SUB:
393 if (!saweval)
394 return 0;
395 cv = cx->blk_sub.cv;
3280af22 396 if (PL_debstash && CvSTASH(cv) == PL_debstash) { /* ignore DB'* scope */
748a9306 397 saweval = i; /* so we know where we were called from */
93a17b20 398 continue;
93a17b20 399 }
748a9306 400 seq = cxstack[saweval].blk_oldcop->cop_seq;
2680586e 401 return pad_findlex(name, newoff, seq, cv, i-1, saweval,FINDLEX_NOSEARCH);
93a17b20
LW
402 }
403 }
404
748a9306
LW
405 return 0;
406}
a0d0e21e 407
748a9306 408PADOFFSET
864dbfa3 409Perl_pad_findmy(pTHX_ char *name)
748a9306
LW
410{
411 I32 off;
54310121 412 I32 pendoff = 0;
748a9306 413 SV *sv;
3280af22
NIS
414 SV **svp = AvARRAY(PL_comppad_name);
415 U32 seq = PL_cop_seqmax;
6b35e009 416 PERL_CONTEXT *cx;
33b8ce05 417 CV *outside;
748a9306 418
11343788
MB
419#ifdef USE_THREADS
420 /*
421 * Special case to get lexical (and hence per-thread) @_.
422 * XXX I need to find out how to tell at parse-time whether use
423 * of @_ should refer to a lexical (from a sub) or defgv (global
424 * scope and maybe weird sub-ish things like formats). See
425 * startsub in perly.y. It's possible that @_ could be lexical
426 * (at least from subs) even in non-threaded perl.
427 */
428 if (strEQ(name, "@_"))
429 return 0; /* success. (NOT_IN_PAD indicates failure) */
430#endif /* USE_THREADS */
431
748a9306 432 /* The one we're looking for is probably just before comppad_name_fill. */
3280af22 433 for (off = AvFILLp(PL_comppad_name); off > 0; off--) {
a0d0e21e 434 if ((sv = svp[off]) &&
3280af22 435 sv != &PL_sv_undef &&
54310121
PP
436 (!SvIVX(sv) ||
437 (seq <= SvIVX(sv) &&
438 seq > I_32(SvNVX(sv)))) &&
a0d0e21e
LW
439 strEQ(SvPVX(sv), name))
440 {
77ca0c92 441 if (SvIVX(sv) || SvFLAGS(sv) & SVpad_OUR)
54310121
PP
442 return (PADOFFSET)off;
443 pendoff = off; /* this pending def. will override import */
a0d0e21e
LW
444 }
445 }
748a9306 446
33b8ce05
GS
447 outside = CvOUTSIDE(PL_compcv);
448
449 /* Check if if we're compiling an eval'', and adjust seq to be the
450 * eval's seq number. This depends on eval'' having a non-null
451 * CvOUTSIDE() while it is being compiled. The eval'' itself is
1aff0e91
GS
452 * identified by CvEVAL being true and CvGV being null. */
453 if (outside && CvEVAL(PL_compcv) && !CvGV(PL_compcv) && cxstack_ix >= 0) {
6b35e009
GS
454 cx = &cxstack[cxstack_ix];
455 if (CxREALEVAL(cx))
456 seq = cx->blk_oldcop->cop_seq;
457 }
458
748a9306 459 /* See if it's in a nested scope */
2680586e 460 off = pad_findlex(name, 0, seq, outside, cxstack_ix, 0, 0);
54310121
PP
461 if (off) {
462 /* If there is a pending local definition, this new alias must die */
463 if (pendoff)
3280af22 464 SvIVX(AvARRAY(PL_comppad_name)[off]) = seq;
11343788 465 return off; /* pad_findlex returns 0 for failure...*/
54310121 466 }
11343788 467 return NOT_IN_PAD; /* ...but we return NOT_IN_PAD for failure */
93a17b20
LW
468}
469
470void
864dbfa3 471Perl_pad_leavemy(pTHX_ I32 fill)
93a17b20
LW
472{
473 I32 off;
3280af22 474 SV **svp = AvARRAY(PL_comppad_name);
93a17b20 475 SV *sv;
3280af22
NIS
476 if (PL_min_intro_pending && fill < PL_min_intro_pending) {
477 for (off = PL_max_intro_pending; off >= PL_min_intro_pending; off--) {
0453d815
PM
478 if ((sv = svp[off]) && sv != &PL_sv_undef && ckWARN_d(WARN_INTERNAL))
479 Perl_warner(aTHX_ WARN_INTERNAL, "%s never introduced", SvPVX(sv));
8990e307
LW
480 }
481 }
482 /* "Deintroduce" my variables that are leaving with this scope. */
3280af22 483 for (off = AvFILLp(PL_comppad_name); off > fill; off--) {
c53d7c7d 484 if ((sv = svp[off]) && sv != &PL_sv_undef && SvIVX(sv) == PAD_MAX)
3280af22 485 SvIVX(sv) = PL_cop_seqmax;
93a17b20
LW
486 }
487}
488
489PADOFFSET
864dbfa3 490Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype)
79072805
LW
491{
492 SV *sv;
493 I32 retval;
494
3280af22 495 if (AvARRAY(PL_comppad) != PL_curpad)
cea2e8a9 496 Perl_croak(aTHX_ "panic: pad_alloc");
3280af22 497 if (PL_pad_reset_pending)
a0d0e21e 498 pad_reset();
ed6116ce 499 if (tmptype & SVs_PADMY) {
79072805 500 do {
3280af22 501 sv = *av_fetch(PL_comppad, AvFILLp(PL_comppad) + 1, TRUE);
ed6116ce 502 } while (SvPADBUSY(sv)); /* need a fresh one */
3280af22 503 retval = AvFILLp(PL_comppad);
79072805
LW
504 }
505 else {
3280af22
NIS
506 SV **names = AvARRAY(PL_comppad_name);
507 SSize_t names_fill = AvFILLp(PL_comppad_name);
bbce6d69
PP
508 for (;;) {
509 /*
510 * "foreach" index vars temporarily become aliases to non-"my"
511 * values. Thus we must skip, not just pad values that are
512 * marked as current pad values, but also those with names.
513 */
3280af22
NIS
514 if (++PL_padix <= names_fill &&
515 (sv = names[PL_padix]) && sv != &PL_sv_undef)
bbce6d69 516 continue;
3280af22 517 sv = *av_fetch(PL_comppad, PL_padix, TRUE);
3049cdab
SB
518 if (!(SvFLAGS(sv) & (SVs_PADTMP|SVs_PADMY)) &&
519 !IS_PADGV(sv) && !IS_PADCONST(sv))
bbce6d69
PP
520 break;
521 }
3280af22 522 retval = PL_padix;
79072805 523 }
8990e307 524 SvFLAGS(sv) |= tmptype;
3280af22 525 PL_curpad = AvARRAY(PL_comppad);
11343788 526#ifdef USE_THREADS
b900a521
JH
527 DEBUG_X(PerlIO_printf(Perl_debug_log,
528 "0x%"UVxf" Pad 0x%"UVxf" alloc %ld for %s\n",
529 PTR2UV(thr), PTR2UV(PL_curpad),
22c35a8c 530 (long) retval, PL_op_name[optype]));
11343788 531#else
b900a521
JH
532 DEBUG_X(PerlIO_printf(Perl_debug_log,
533 "Pad 0x%"UVxf" alloc %ld for %s\n",
534 PTR2UV(PL_curpad),
22c35a8c 535 (long) retval, PL_op_name[optype]));
11343788 536#endif /* USE_THREADS */
79072805
LW
537 return (PADOFFSET)retval;
538}
539
540SV *
864dbfa3 541Perl_pad_sv(pTHX_ PADOFFSET po)
79072805 542{
11343788 543#ifdef USE_THREADS
b900a521 544 DEBUG_X(PerlIO_printf(Perl_debug_log,
f1dbda3d
JH
545 "0x%"UVxf" Pad 0x%"UVxf" sv %"IVdf"\n",
546 PTR2UV(thr), PTR2UV(PL_curpad), (IV)po));
11343788 547#else
79072805 548 if (!po)
cea2e8a9 549 Perl_croak(aTHX_ "panic: pad_sv po");
97835f67
JH
550 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" sv %"IVdf"\n",
551 PTR2UV(PL_curpad), (IV)po));
11343788 552#endif /* USE_THREADS */
3280af22 553 return PL_curpad[po]; /* eventually we'll turn this into a macro */
79072805
LW
554}
555
556void
864dbfa3 557Perl_pad_free(pTHX_ PADOFFSET po)
79072805 558{
3280af22 559 if (!PL_curpad)
a0d0e21e 560 return;
3280af22 561 if (AvARRAY(PL_comppad) != PL_curpad)
cea2e8a9 562 Perl_croak(aTHX_ "panic: pad_free curpad");
79072805 563 if (!po)
cea2e8a9 564 Perl_croak(aTHX_ "panic: pad_free po");
11343788 565#ifdef USE_THREADS
b900a521 566 DEBUG_X(PerlIO_printf(Perl_debug_log,
7766f137 567 "0x%"UVxf" Pad 0x%"UVxf" free %"IVdf"\n",
f1dbda3d 568 PTR2UV(thr), PTR2UV(PL_curpad), (IV)po));
11343788 569#else
97835f67
JH
570 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" free %"IVdf"\n",
571 PTR2UV(PL_curpad), (IV)po));
11343788 572#endif /* USE_THREADS */
2aa1bedc 573 if (PL_curpad[po] && PL_curpad[po] != &PL_sv_undef) {
3280af22 574 SvPADTMP_off(PL_curpad[po]);
2aa1bedc
GS
575#ifdef USE_ITHREADS
576 SvREADONLY_off(PL_curpad[po]); /* could be a freed constant */
577#endif
578 }
3280af22
NIS
579 if ((I32)po < PL_padix)
580 PL_padix = po - 1;
79072805
LW
581}
582
583void
864dbfa3 584Perl_pad_swipe(pTHX_ PADOFFSET po)
79072805 585{
3280af22 586 if (AvARRAY(PL_comppad) != PL_curpad)
cea2e8a9 587 Perl_croak(aTHX_ "panic: pad_swipe curpad");
79072805 588 if (!po)
cea2e8a9 589 Perl_croak(aTHX_ "panic: pad_swipe po");
11343788 590#ifdef USE_THREADS
b900a521 591 DEBUG_X(PerlIO_printf(Perl_debug_log,
f1dbda3d
JH
592 "0x%"UVxf" Pad 0x%"UVxf" swipe %"IVdf"\n",
593 PTR2UV(thr), PTR2UV(PL_curpad), (IV)po));
11343788 594#else
97835f67
JH
595 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" swipe %"IVdf"\n",
596 PTR2UV(PL_curpad), (IV)po));
11343788 597#endif /* USE_THREADS */
3280af22
NIS
598 SvPADTMP_off(PL_curpad[po]);
599 PL_curpad[po] = NEWSV(1107,0);
600 SvPADTMP_on(PL_curpad[po]);
601 if ((I32)po < PL_padix)
602 PL_padix = po - 1;
79072805
LW
603}
604
d9bb4600
GS
605/* XXX pad_reset() is currently disabled because it results in serious bugs.
606 * It causes pad temp TARGs to be shared between OPs. Since TARGs are pushed
607 * on the stack by OPs that use them, there are several ways to get an alias
608 * to a shared TARG. Such an alias will change randomly and unpredictably.
609 * We avoid doing this until we can think of a Better Way.
610 * GSAR 97-10-29 */
79072805 611void
864dbfa3 612Perl_pad_reset(pTHX)
79072805 613{
d9bb4600 614#ifdef USE_BROKEN_PAD_RESET
79072805
LW
615 register I32 po;
616
6b88bc9c 617 if (AvARRAY(PL_comppad) != PL_curpad)
cea2e8a9 618 Perl_croak(aTHX_ "panic: pad_reset curpad");
11343788 619#ifdef USE_THREADS
b900a521
JH
620 DEBUG_X(PerlIO_printf(Perl_debug_log,
621 "0x%"UVxf" Pad 0x%"UVxf" reset\n",
622 PTR2UV(thr), PTR2UV(PL_curpad)));
11343788 623#else
b900a521
JH
624 DEBUG_X(PerlIO_printf(Perl_debug_log, "Pad 0x%"UVxf" reset\n",
625 PTR2UV(PL_curpad)));
11343788 626#endif /* USE_THREADS */
6b88bc9c
GS
627 if (!PL_tainting) { /* Can't mix tainted and non-tainted temporaries. */
628 for (po = AvMAX(PL_comppad); po > PL_padix_floor; po--) {
629 if (PL_curpad[po] && !SvIMMORTAL(PL_curpad[po]))
630 SvPADTMP_off(PL_curpad[po]);
748a9306 631 }
6b88bc9c 632 PL_padix = PL_padix_floor;
79072805 633 }
d9bb4600 634#endif
3280af22 635 PL_pad_reset_pending = FALSE;
79072805
LW
636}
637
a863c7d1 638#ifdef USE_THREADS
54b9620d 639/* find_threadsv is not reentrant */
a863c7d1 640PADOFFSET
864dbfa3 641Perl_find_threadsv(pTHX_ const char *name)
a863c7d1 642{
a863c7d1
MB
643 char *p;
644 PADOFFSET key;
554b3eca 645 SV **svp;
54b9620d 646 /* We currently only handle names of a single character */
533c011a 647 p = strchr(PL_threadsv_names, *name);
a863c7d1
MB
648 if (!p)
649 return NOT_IN_PAD;
533c011a 650 key = p - PL_threadsv_names;
2d8e6c8d 651 MUTEX_LOCK(&thr->mutex);
54b9620d 652 svp = av_fetch(thr->threadsv, key, FALSE);
2d8e6c8d
GS
653 if (svp)
654 MUTEX_UNLOCK(&thr->mutex);
655 else {
554b3eca 656 SV *sv = NEWSV(0, 0);
54b9620d 657 av_store(thr->threadsv, key, sv);
940cb80d 658 thr->threadsvp = AvARRAY(thr->threadsv);
2d8e6c8d 659 MUTEX_UNLOCK(&thr->mutex);
554b3eca
MB
660 /*
661 * Some magic variables used to be automagically initialised
662 * in gv_fetchpv. Those which are now per-thread magicals get
663 * initialised here instead.
664 */
665 switch (*name) {
54b9620d
MB
666 case '_':
667 break;
554b3eca
MB
668 case ';':
669 sv_setpv(sv, "\034");
1c846c1f 670 sv_magic(sv, 0, 0, name, 1);
554b3eca 671 break;
c277df42
IZ
672 case '&':
673 case '`':
674 case '\'':
533c011a 675 PL_sawampersand = TRUE;
a3f914c5
GS
676 /* FALL THROUGH */
677 case '1':
678 case '2':
679 case '3':
680 case '4':
681 case '5':
682 case '6':
683 case '7':
684 case '8':
685 case '9':
c277df42 686 SvREADONLY_on(sv);
d8b5173a 687 /* FALL THROUGH */
067391ea
GS
688
689 /* XXX %! tied to Errno.pm needs to be added here.
690 * See gv_fetchpv(). */
691 /* case '!': */
692
54b9620d 693 default:
1c846c1f 694 sv_magic(sv, 0, 0, name, 1);
554b3eca 695 }
bf49b057 696 DEBUG_S(PerlIO_printf(Perl_error_log,
54b9620d 697 "find_threadsv: new SV %p for $%s%c\n",
554b3eca
MB
698 sv, (*name < 32) ? "^" : "",
699 (*name < 32) ? toCTRL(*name) : *name));
a863c7d1
MB
700 }
701 return key;
702}
703#endif /* USE_THREADS */
704
79072805
LW
705/* Destructor */
706
707void
864dbfa3 708Perl_op_free(pTHX_ OP *o)
79072805 709{
85e6fe83 710 register OP *kid, *nextkid;
acb36ea4 711 OPCODE type;
79072805 712
5dc0d613 713 if (!o || o->op_seq == (U16)-1)
79072805
LW
714 return;
715
7934575e
GS
716 if (o->op_private & OPpREFCOUNTED) {
717 switch (o->op_type) {
718 case OP_LEAVESUB:
719 case OP_LEAVESUBLV:
720 case OP_LEAVEEVAL:
721 case OP_LEAVE:
722 case OP_SCOPE:
723 case OP_LEAVEWRITE:
724 OP_REFCNT_LOCK;
725 if (OpREFCNT_dec(o)) {
726 OP_REFCNT_UNLOCK;
727 return;
728 }
729 OP_REFCNT_UNLOCK;
730 break;
731 default:
732 break;
733 }
734 }
735
11343788
MB
736 if (o->op_flags & OPf_KIDS) {
737 for (kid = cUNOPo->op_first; kid; kid = nextkid) {
85e6fe83 738 nextkid = kid->op_sibling; /* Get before next freeing kid */
79072805 739 op_free(kid);
85e6fe83 740 }
79072805 741 }
acb36ea4
GS
742 type = o->op_type;
743 if (type == OP_NULL)
744 type = o->op_targ;
745
746 /* COP* is not cleared by op_clear() so that we may track line
747 * numbers etc even after null() */
748 if (type == OP_NEXTSTATE || type == OP_SETSTATE || type == OP_DBSTATE)
749 cop_free((COP*)o);
750
751 op_clear(o);
752
753#ifdef PL_OP_SLAB_ALLOC
754 if ((char *) o == PL_OpPtr)
755 {
756 }
757#else
758 Safefree(o);
759#endif
760}
79072805 761
acb36ea4
GS
762STATIC void
763S_op_clear(pTHX_ OP *o)
764{
11343788 765 switch (o->op_type) {
acb36ea4
GS
766 case OP_NULL: /* Was holding old type, if any. */
767 case OP_ENTEREVAL: /* Was holding hints. */
768#ifdef USE_THREADS
769 case OP_THREADSV: /* Was holding index into thr->threadsv AV. */
770#endif
771 o->op_targ = 0;
a0d0e21e 772 break;
554b3eca 773#ifdef USE_THREADS
8dd3ba40
SM
774 case OP_ENTERITER:
775 if (!(o->op_flags & OPf_SPECIAL))
776 break;
777 /* FALL THROUGH */
554b3eca 778#endif /* USE_THREADS */
a6006777 779 default:
ac4c12e7 780 if (!(o->op_flags & OPf_REF)
0b94c7bb 781 || (PL_check[o->op_type] != MEMBER_TO_FPTR(Perl_ck_ftst)))
a6006777
PP
782 break;
783 /* FALL THROUGH */
463ee0b2 784 case OP_GVSV:
79072805 785 case OP_GV:
a6006777 786 case OP_AELEMFAST:
350de78d 787#ifdef USE_ITHREADS
971a9dd3
GS
788 if (cPADOPo->op_padix > 0) {
789 if (PL_curpad) {
638eceb6 790 GV *gv = cGVOPo_gv;
971a9dd3
GS
791 pad_swipe(cPADOPo->op_padix);
792 /* No GvIN_PAD_off(gv) here, because other references may still
793 * exist on the pad */
794 SvREFCNT_dec(gv);
795 }
796 cPADOPo->op_padix = 0;
797 }
350de78d 798#else
971a9dd3 799 SvREFCNT_dec(cSVOPo->op_sv);
7934575e 800 cSVOPo->op_sv = Nullsv;
350de78d 801#endif
79072805 802 break;
a1ae71d2 803 case OP_METHOD_NAMED:
79072805 804 case OP_CONST:
11343788 805 SvREFCNT_dec(cSVOPo->op_sv);
acb36ea4 806 cSVOPo->op_sv = Nullsv;
79072805 807 break;
748a9306
LW
808 case OP_GOTO:
809 case OP_NEXT:
810 case OP_LAST:
811 case OP_REDO:
11343788 812 if (o->op_flags & (OPf_SPECIAL|OPf_STACKED|OPf_KIDS))
748a9306
LW
813 break;
814 /* FALL THROUGH */
a0d0e21e 815 case OP_TRANS:
acb36ea4 816 if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
a0ed51b3 817 SvREFCNT_dec(cSVOPo->op_sv);
acb36ea4
GS
818 cSVOPo->op_sv = Nullsv;
819 }
820 else {
a0ed51b3 821 Safefree(cPVOPo->op_pv);
acb36ea4
GS
822 cPVOPo->op_pv = Nullch;
823 }
a0d0e21e
LW
824 break;
825 case OP_SUBST:
11343788 826 op_free(cPMOPo->op_pmreplroot);
971a9dd3 827 goto clear_pmop;
748a9306 828 case OP_PUSHRE:
971a9dd3
GS
829#ifdef USE_ITHREADS
830 if ((PADOFFSET)cPMOPo->op_pmreplroot) {
831 if (PL_curpad) {
832 GV *gv = (GV*)PL_curpad[(PADOFFSET)cPMOPo->op_pmreplroot];
833 pad_swipe((PADOFFSET)cPMOPo->op_pmreplroot);
834 /* No GvIN_PAD_off(gv) here, because other references may still
835 * exist on the pad */
836 SvREFCNT_dec(gv);
837 }
838 }
839#else
840 SvREFCNT_dec((SV*)cPMOPo->op_pmreplroot);
841#endif
842 /* FALL THROUGH */
a0d0e21e 843 case OP_MATCH:
8782bef2 844 case OP_QR:
971a9dd3
GS
845clear_pmop:
846 cPMOPo->op_pmreplroot = Nullop;
c277df42 847 ReREFCNT_dec(cPMOPo->op_pmregexp);
acb36ea4 848 cPMOPo->op_pmregexp = (REGEXP*)NULL;
a0d0e21e 849 break;
79072805
LW
850 }
851
743e66e6 852 if (o->op_targ > 0) {
11343788 853 pad_free(o->op_targ);
743e66e6
GS
854 o->op_targ = 0;
855 }
79072805
LW
856}
857
76e3520e 858STATIC void
3eb57f73
HS
859S_cop_free(pTHX_ COP* cop)
860{
861 Safefree(cop->cop_label);
57843af0 862#ifdef USE_ITHREADS
f4dd75d9
GS
863 Safefree(CopFILE(cop)); /* XXX share in a pvtable? */
864 Safefree(CopSTASHPV(cop)); /* XXX share in a pvtable? */
57843af0 865#else
11faa288 866 /* NOTE: COP.cop_stash is not refcounted */
cc49e20b 867 SvREFCNT_dec(CopFILEGV(cop));
57843af0 868#endif
0453d815 869 if (! specialWARN(cop->cop_warnings))
3eb57f73 870 SvREFCNT_dec(cop->cop_warnings);
ac27b0f5
NIS
871 if (! specialCopIO(cop->cop_io))
872 SvREFCNT_dec(cop->cop_io);
3eb57f73
HS
873}
874
875STATIC void
cea2e8a9 876S_null(pTHX_ OP *o)
8990e307 877{
acb36ea4
GS
878 if (o->op_type == OP_NULL)
879 return;
880 op_clear(o);
11343788
MB
881 o->op_targ = o->op_type;
882 o->op_type = OP_NULL;
22c35a8c 883 o->op_ppaddr = PL_ppaddr[OP_NULL];
8990e307
LW
884}
885
79072805
LW
886/* Contextualizers */
887
463ee0b2 888#define LINKLIST(o) ((o)->op_next ? (o)->op_next : linklist((OP*)o))
79072805
LW
889
890OP *
864dbfa3 891Perl_linklist(pTHX_ OP *o)
79072805
LW
892{
893 register OP *kid;
894
11343788
MB
895 if (o->op_next)
896 return o->op_next;
79072805
LW
897
898 /* establish postfix order */
11343788
MB
899 if (cUNOPo->op_first) {
900 o->op_next = LINKLIST(cUNOPo->op_first);
901 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling) {
79072805
LW
902 if (kid->op_sibling)
903 kid->op_next = LINKLIST(kid->op_sibling);
904 else
11343788 905 kid->op_next = o;
79072805
LW
906 }
907 }
908 else
11343788 909 o->op_next = o;
79072805 910
11343788 911 return o->op_next;
79072805
LW
912}
913
914OP *
864dbfa3 915Perl_scalarkids(pTHX_ OP *o)
79072805
LW
916{
917 OP *kid;
11343788
MB
918 if (o && o->op_flags & OPf_KIDS) {
919 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW
920 scalar(kid);
921 }
11343788 922 return o;
79072805
LW
923}
924
76e3520e 925STATIC OP *
cea2e8a9 926S_scalarboolean(pTHX_ OP *o)
8990e307 927{
d008e5eb 928 if (o->op_type == OP_SASSIGN && cBINOPo->op_first->op_type == OP_CONST) {
d008e5eb 929 if (ckWARN(WARN_SYNTAX)) {
57843af0 930 line_t oldline = CopLINE(PL_curcop);
a0d0e21e 931
d008e5eb 932 if (PL_copline != NOLINE)
57843af0 933 CopLINE_set(PL_curcop, PL_copline);
cea2e8a9 934 Perl_warner(aTHX_ WARN_SYNTAX, "Found = in conditional, should be ==");
57843af0 935 CopLINE_set(PL_curcop, oldline);
d008e5eb 936 }
a0d0e21e 937 }
11343788 938 return scalar(o);
8990e307
LW
939}
940
941OP *
864dbfa3 942Perl_scalar(pTHX_ OP *o)
79072805
LW
943{
944 OP *kid;
945
a0d0e21e 946 /* assumes no premature commitment */
3280af22 947 if (!o || (o->op_flags & OPf_WANT) || PL_error_count
5dc0d613 948 || o->op_type == OP_RETURN)
7e363e51 949 {
11343788 950 return o;
7e363e51 951 }
79072805 952
5dc0d613 953 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_SCALAR;
79072805 954
11343788 955 switch (o->op_type) {
79072805 956 case OP_REPEAT:
11343788
MB
957 if (o->op_private & OPpREPEAT_DOLIST)
958 null(((LISTOP*)cBINOPo->op_first)->op_first);
959 scalar(cBINOPo->op_first);
8990e307 960 break;
79072805
LW
961 case OP_OR:
962 case OP_AND:
963 case OP_COND_EXPR:
11343788 964 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
8990e307 965 scalar(kid);
79072805 966 break;
a0d0e21e 967 case OP_SPLIT:
11343788 968 if ((kid = cLISTOPo->op_first) && kid->op_type == OP_PUSHRE) {
a0d0e21e
LW
969 if (!kPMOP->op_pmreplroot)
970 deprecate("implicit split to @_");
971 }
972 /* FALL THROUGH */
79072805 973 case OP_MATCH:
8782bef2 974 case OP_QR:
79072805
LW
975 case OP_SUBST:
976 case OP_NULL:
8990e307 977 default:
11343788
MB
978 if (o->op_flags & OPf_KIDS) {
979 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
8990e307
LW
980 scalar(kid);
981 }
79072805
LW
982 break;
983 case OP_LEAVE:
984 case OP_LEAVETRY:
5dc0d613 985 kid = cLISTOPo->op_first;
54310121 986 scalar(kid);
155aba94 987 while ((kid = kid->op_sibling)) {
54310121
PP
988 if (kid->op_sibling)
989 scalarvoid(kid);
990 else
991 scalar(kid);
992 }
3280af22 993 WITH_THR(PL_curcop = &PL_compiling);
54310121 994 break;
748a9306 995 case OP_SCOPE:
79072805 996 case OP_LINESEQ:
8990e307 997 case OP_LIST:
11343788 998 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
79072805
LW
999 if (kid->op_sibling)
1000 scalarvoid(kid);
1001 else
1002 scalar(kid);
1003 }
3280af22 1004 WITH_THR(PL_curcop = &PL_compiling);
79072805
LW
1005 break;
1006 }
11343788 1007 return o;
79072805
LW
1008}
1009
1010OP *
864dbfa3 1011Perl_scalarvoid(pTHX_ OP *o)
79072805
LW
1012{
1013 OP *kid;
8990e307
LW
1014 char* useless = 0;
1015 SV* sv;
2ebea0a1
GS
1016 U8 want;
1017
acb36ea4
GS
1018 if (o->op_type == OP_NEXTSTATE
1019 || o->op_type == OP_SETSTATE
1020 || o->op_type == OP_DBSTATE
1021 || (o->op_type == OP_NULL && (o->op_targ == OP_NEXTSTATE
1022 || o->op_targ == OP_SETSTATE
1023 || o->op_targ == OP_DBSTATE)))
2ebea0a1 1024 PL_curcop = (COP*)o; /* for warning below */
79072805 1025
54310121 1026 /* assumes no premature commitment */
2ebea0a1
GS
1027 want = o->op_flags & OPf_WANT;
1028 if ((want && want != OPf_WANT_SCALAR) || PL_error_count
5dc0d613 1029 || o->op_type == OP_RETURN)
7e363e51 1030 {
11343788 1031 return o;
7e363e51 1032 }
79072805 1033
b162f9ea 1034 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS
1035 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1036 {
b162f9ea 1037 return scalar(o); /* As if inside SASSIGN */
7e363e51 1038 }
1c846c1f 1039
5dc0d613 1040 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_VOID;
79072805 1041
11343788 1042 switch (o->op_type) {
79072805 1043 default:
22c35a8c 1044 if (!(PL_opargs[o->op_type] & OA_FOLDCONST))
8990e307 1045 break;
36477c24
PP
1046 /* FALL THROUGH */
1047 case OP_REPEAT:
11343788 1048 if (o->op_flags & OPf_STACKED)
8990e307 1049 break;
5d82c453
GA
1050 goto func_ops;
1051 case OP_SUBSTR:
1052 if (o->op_private == 4)
1053 break;
8990e307
LW
1054 /* FALL THROUGH */
1055 case OP_GVSV:
1056 case OP_WANTARRAY:
1057 case OP_GV:
1058 case OP_PADSV:
1059 case OP_PADAV:
1060 case OP_PADHV:
1061 case OP_PADANY:
1062 case OP_AV2ARYLEN:
8990e307 1063 case OP_REF:
a0d0e21e
LW
1064 case OP_REFGEN:
1065 case OP_SREFGEN:
8990e307
LW
1066 case OP_DEFINED:
1067 case OP_HEX:
1068 case OP_OCT:
1069 case OP_LENGTH:
8990e307
LW
1070 case OP_VEC:
1071 case OP_INDEX:
1072 case OP_RINDEX:
1073 case OP_SPRINTF:
1074 case OP_AELEM:
1075 case OP_AELEMFAST:
1076 case OP_ASLICE:
8990e307
LW
1077 case OP_HELEM:
1078 case OP_HSLICE:
1079 case OP_UNPACK:
1080 case OP_PACK:
8990e307
LW
1081 case OP_JOIN:
1082 case OP_LSLICE:
1083 case OP_ANONLIST:
1084 case OP_ANONHASH:
1085 case OP_SORT:
1086 case OP_REVERSE:
1087 case OP_RANGE:
1088 case OP_FLIP:
1089 case OP_FLOP:
1090 case OP_CALLER:
1091 case OP_FILENO:
1092 case OP_EOF:
1093 case OP_TELL:
1094 case OP_GETSOCKNAME:
1095 case OP_GETPEERNAME:
1096 case OP_READLINK:
1097 case OP_TELLDIR:
1098 case OP_GETPPID:
1099 case OP_GETPGRP:
1100 case OP_GETPRIORITY:
1101 case OP_TIME:
1102 case OP_TMS:
1103 case OP_LOCALTIME:
1104 case OP_GMTIME:
1105 case OP_GHBYNAME:
1106 case OP_GHBYADDR:
1107 case OP_GHOSTENT:
1108 case OP_GNBYNAME:
1109 case OP_GNBYADDR:
1110 case OP_GNETENT:
1111 case OP_GPBYNAME:
1112 case OP_GPBYNUMBER:
1113 case OP_GPROTOENT:
1114 case OP_GSBYNAME:
1115 case OP_GSBYPORT:
1116 case OP_GSERVENT:
1117 case OP_GPWNAM:
1118 case OP_GPWUID:
1119 case OP_GGRNAM:
1120 case OP_GGRGID:
1121 case OP_GETLOGIN:
5d82c453 1122 func_ops:
64aac5a9 1123 if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)))
22c35a8c 1124 useless = PL_op_desc[o->op_type];
8990e307
LW
1125 break;
1126
1127 case OP_RV2GV:
1128 case OP_RV2SV:
1129 case OP_RV2AV:
1130 case OP_RV2HV:
192587c2 1131 if (!(o->op_private & (OPpLVAL_INTRO|OPpOUR_INTRO)) &&
11343788 1132 (!o->op_sibling || o->op_sibling->op_type != OP_READLINE))
8990e307
LW
1133 useless = "a variable";
1134 break;
79072805
LW
1135
1136 case OP_CONST:
7766f137 1137 sv = cSVOPo_sv;
7a52d87a
GS
1138 if (cSVOPo->op_private & OPpCONST_STRICT)
1139 no_bareword_allowed(o);
1140 else {
d008e5eb
GS
1141 if (ckWARN(WARN_VOID)) {
1142 useless = "a constant";
1143 if (SvNIOK(sv) && (SvNV(sv) == 0.0 || SvNV(sv) == 1.0))
1144 useless = 0;
1145 else if (SvPOK(sv)) {
a52fe3ac
A
1146 /* perl4's way of mixing documentation and code
1147 (before the invention of POD) was based on a
1148 trick to mix nroff and perl code. The trick was
1149 built upon these three nroff macros being used in
1150 void context. The pink camel has the details in
1151 the script wrapman near page 319. */
d008e5eb
GS
1152 if (strnEQ(SvPVX(sv), "di", 2) ||
1153 strnEQ(SvPVX(sv), "ds", 2) ||
1154 strnEQ(SvPVX(sv), "ig", 2))
1155 useless = 0;
1156 }
8990e307
LW
1157 }
1158 }
acb36ea4 1159 null(o); /* don't execute or even remember it */
79072805
LW
1160 break;
1161
1162 case OP_POSTINC:
11343788 1163 o->op_type = OP_PREINC; /* pre-increment is faster */
22c35a8c 1164 o->op_ppaddr = PL_ppaddr[OP_PREINC];
79072805
LW
1165 break;
1166
1167 case OP_POSTDEC:
11343788 1168 o->op_type = OP_PREDEC; /* pre-decrement is faster */
22c35a8c 1169 o->op_ppaddr = PL_ppaddr[OP_PREDEC];
79072805
LW
1170 break;
1171
79072805
LW
1172 case OP_OR:
1173 case OP_AND:
1174 case OP_COND_EXPR:
11343788 1175 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
79072805
LW
1176 scalarvoid(kid);
1177 break;
5aabfad6 1178
a0d0e21e 1179 case OP_NULL:
11343788 1180 if (o->op_flags & OPf_STACKED)
a0d0e21e 1181 break;
5aabfad6 1182 /* FALL THROUGH */
2ebea0a1
GS
1183 case OP_NEXTSTATE:
1184 case OP_DBSTATE:
79072805
LW
1185 case OP_ENTERTRY:
1186 case OP_ENTER:
11343788 1187 if (!(o->op_flags & OPf_KIDS))
79072805 1188 break;
54310121 1189 /* FALL THROUGH */
463ee0b2 1190 case OP_SCOPE:
79072805
LW
1191 case OP_LEAVE:
1192 case OP_LEAVETRY:
a0d0e21e 1193 case OP_LEAVELOOP:
79072805 1194 case OP_LINESEQ:
79072805 1195 case OP_LIST:
11343788 1196 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW
1197 scalarvoid(kid);
1198 break;
c90c0ff4 1199 case OP_ENTEREVAL:
5196be3e 1200 scalarkids(o);
c90c0ff4 1201 break;
5aabfad6 1202 case OP_REQUIRE:
c90c0ff4 1203 /* all requires must return a boolean value */
5196be3e 1204 o->op_flags &= ~OPf_WANT;
d6483035
GS
1205 /* FALL THROUGH */
1206 case OP_SCALAR:
5196be3e 1207 return scalar(o);
a0d0e21e 1208 case OP_SPLIT:
11343788 1209 if ((kid = cLISTOPo->op_first) && kid->op_type == OP_PUSHRE) {
a0d0e21e
LW
1210 if (!kPMOP->op_pmreplroot)
1211 deprecate("implicit split to @_");
1212 }
1213 break;
79072805 1214 }
411caa50
JH
1215 if (useless && ckWARN(WARN_VOID))
1216 Perl_warner(aTHX_ WARN_VOID, "Useless use of %s in void context", useless);
11343788 1217 return o;
79072805
LW
1218}
1219
1220OP *
864dbfa3 1221Perl_listkids(pTHX_ OP *o)
79072805
LW
1222{
1223 OP *kid;
11343788
MB
1224 if (o && o->op_flags & OPf_KIDS) {
1225 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
79072805
LW
1226 list(kid);
1227 }
11343788 1228 return o;
79072805
LW
1229}
1230
1231OP *
864dbfa3 1232Perl_list(pTHX_ OP *o)
79072805
LW
1233{
1234 OP *kid;
1235
a0d0e21e 1236 /* assumes no premature commitment */
3280af22 1237 if (!o || (o->op_flags & OPf_WANT) || PL_error_count
5dc0d613 1238 || o->op_type == OP_RETURN)
7e363e51 1239 {
11343788 1240 return o;
7e363e51 1241 }
79072805 1242
b162f9ea 1243 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS
1244 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1245 {
b162f9ea 1246 return o; /* As if inside SASSIGN */
7e363e51 1247 }
1c846c1f 1248
5dc0d613 1249 o->op_flags = (o->op_flags & ~OPf_WANT) | OPf_WANT_LIST;
79072805 1250
11343788 1251 switch (o->op_type) {
79072805
LW
1252 case OP_FLOP:
1253 case OP_REPEAT:
11343788 1254 list(cBINOPo->op_first);
79072805
LW
1255 break;
1256 case OP_OR:
1257 case OP_AND:
1258 case OP_COND_EXPR:
11343788 1259 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
79072805
LW
1260 list(kid);
1261 break;
1262 default:
1263 case OP_MATCH:
8782bef2 1264 case OP_QR:
79072805
LW
1265 case OP_SUBST:
1266 case OP_NULL:
11343788 1267 if (!(o->op_flags & OPf_KIDS))
79072805 1268 break;
11343788
MB
1269 if (!o->op_next && cUNOPo->op_first->op_type == OP_FLOP) {
1270 list(cBINOPo->op_first);
1271 return gen_constant_list(o);
79072805
LW
1272 }
1273 case OP_LIST:
11343788 1274 listkids(o);
79072805
LW
1275 break;
1276 case OP_LEAVE:
1277 case OP_LEAVETRY:
5dc0d613 1278 kid = cLISTOPo->op_first;
54310121 1279 list(kid);
155aba94 1280 while ((kid = kid->op_sibling)) {
54310121
PP
1281 if (kid->op_sibling)
1282 scalarvoid(kid);
1283 else
1284 list(kid);
1285 }
3280af22 1286 WITH_THR(PL_curcop = &PL_compiling);
54310121 1287 break;
748a9306 1288 case OP_SCOPE:
79072805 1289 case OP_LINESEQ:
11343788 1290 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
79072805
LW
1291 if (kid->op_sibling)
1292 scalarvoid(kid);
1293 else
1294 list(kid);
1295 }
3280af22 1296 WITH_THR(PL_curcop = &PL_compiling);
79072805 1297 break;
c90c0ff4
PP
1298 case OP_REQUIRE:
1299 /* all requires must return a boolean value */
5196be3e
MB
1300 o->op_flags &= ~OPf_WANT;
1301 return scalar(o);
79072805 1302 }
11343788 1303 return o;
79072805
LW
1304}
1305
1306OP *
864dbfa3 1307Perl_scalarseq(pTHX_ OP *o)
79072805
LW
1308{
1309 OP *kid;
1310
11343788
MB
1311 if (o) {
1312 if (o->op_type == OP_LINESEQ ||
1313 o->op_type == OP_SCOPE ||
1314 o->op_type == OP_LEAVE ||
1315 o->op_type == OP_LEAVETRY)
463ee0b2 1316 {
11343788 1317 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling) {
ed6116ce 1318 if (kid->op_sibling) {
463ee0b2 1319 scalarvoid(kid);
ed6116ce 1320 }
463ee0b2 1321 }
3280af22 1322 PL_curcop = &PL_compiling;
79072805 1323 }
11343788 1324 o->op_flags &= ~OPf_PARENS;
3280af22 1325 if (PL_hints & HINT_BLOCK_SCOPE)
11343788 1326 o->op_flags |= OPf_PARENS;
79072805 1327 }
8990e307 1328 else
11343788
MB
1329 o = newOP(OP_STUB, 0);
1330 return o;
79072805
LW
1331}
1332
76e3520e 1333STATIC OP *
cea2e8a9 1334S_modkids(pTHX_ OP *o, I32 type)
79072805
LW
1335{
1336 OP *kid;
11343788
MB
1337 if (o && o->op_flags & OPf_KIDS) {
1338 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
463ee0b2 1339 mod(kid, type);
79072805 1340 }
11343788 1341 return o;
79072805
LW
1342}
1343
79072805 1344OP *
864dbfa3 1345Perl_mod(pTHX_ OP *o, I32 type)
79072805
LW
1346{
1347 OP *kid;
2d8e6c8d 1348 STRLEN n_a;
79072805 1349
3280af22 1350 if (!o || PL_error_count)
11343788 1351 return o;
79072805 1352
b162f9ea 1353 if ((o->op_private & OPpTARGET_MY)
7e363e51
GS
1354 && (PL_opargs[o->op_type] & OA_TARGLEX))/* OPp share the meaning */
1355 {
b162f9ea 1356 return o;
7e363e51 1357 }
1c846c1f 1358
11343788 1359 switch (o->op_type) {
68dc0745 1360 case OP_UNDEF:
3280af22 1361 PL_modcount++;
5dc0d613 1362 return o;
a0d0e21e 1363 case OP_CONST:
9041c2e3 1364 if (o->op_private & (OPpCONST_BARE) &&
d38a0a14
SC
1365 !(type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN)) {
1366 SV *sv = ((SVOP*)o)->op_sv;
1367 GV *gv;
1368
1369 /* Could be a filehandle */
9cbac4c7 1370 if ((gv = gv_fetchpv(SvPV_nolen(sv), FALSE, SVt_PVIO))) {
d38a0a14
SC
1371 OP* gvio = newUNOP(OP_RV2GV, 0, newGVOP(OP_GV, 0, gv));
1372 op_free(o);
1373 o = gvio;
1374 } else {
1375 /* OK, it's a sub */
1376 OP* enter;
1377 gv = gv_fetchpv(SvPV_nolen(sv), TRUE, SVt_PVCV);
1378
9041c2e3
NIS
1379 enter = newUNOP(OP_ENTERSUB,0,
1380 newUNOP(OP_RV2CV, 0,
d38a0a14
SC
1381 newGVOP(OP_GV, 0, gv)
1382 ));
1383 enter->op_private |= OPpLVAL_INTRO;
1384 op_free(o);
1385 o = enter;
1386 }
1387 break;
1388 }
11343788 1389 if (!(o->op_private & (OPpCONST_ARYBASE)))
a0d0e21e 1390 goto nomod;
3280af22 1391 if (PL_eval_start && PL_eval_start->op_type == OP_CONST) {
7766f137 1392 PL_compiling.cop_arybase = (I32)SvIV(cSVOPx(PL_eval_start)->op_sv);
3280af22 1393 PL_eval_start = 0;
a0d0e21e
LW
1394 }
1395 else if (!type) {
3280af22
NIS
1396 SAVEI32(PL_compiling.cop_arybase);
1397 PL_compiling.cop_arybase = 0;
a0d0e21e
LW
1398 }
1399 else if (type == OP_REFGEN)
1400 goto nomod;
1401 else
cea2e8a9 1402 Perl_croak(aTHX_ "That use of $[ is unsupported");
a0d0e21e 1403 break;
5f05dabc 1404 case OP_STUB:
5196be3e 1405 if (o->op_flags & OPf_PARENS)
5f05dabc
PP
1406 break;
1407 goto nomod;
a0d0e21e
LW
1408 case OP_ENTERSUB:
1409 if ((type == OP_UNDEF || type == OP_REFGEN) &&
11343788
MB
1410 !(o->op_flags & OPf_STACKED)) {
1411 o->op_type = OP_RV2CV; /* entersub => rv2cv */
22c35a8c 1412 o->op_ppaddr = PL_ppaddr[OP_RV2CV];
11343788
MB
1413 assert(cUNOPo->op_first->op_type == OP_NULL);
1414 null(((LISTOP*)cUNOPo->op_first)->op_first);/* disable pushmark */
79072805
LW
1415 break;
1416 }
cd06dffe
GS
1417 else { /* lvalue subroutine call */
1418 o->op_private |= OPpLVAL_INTRO;
e6438c1a 1419 PL_modcount = RETURN_UNLIMITED_NUMBER;
4978d6d9 1420 if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN) {
cd06dffe
GS
1421 /* Backward compatibility mode: */
1422 o->op_private |= OPpENTERSUB_INARGS;
1423 break;
1424 }
1425 else { /* Compile-time error message: */
1426 OP *kid = cUNOPo->op_first;
1427 CV *cv;
1428 OP *okid;
1429
1430 if (kid->op_type == OP_PUSHMARK)
1431 goto skip_kids;
1432 if (kid->op_type != OP_NULL || kid->op_targ != OP_LIST)
1433 Perl_croak(aTHX_
1434 "panic: unexpected lvalue entersub "
1435 "args: type/targ %ld:%ld",
1436 (long)kid->op_type,kid->op_targ);
1437 kid = kLISTOP->op_first;
1438 skip_kids:
1439 while (kid->op_sibling)
1440 kid = kid->op_sibling;
1441 if (!(kid->op_type == OP_NULL && kid->op_targ == OP_RV2CV)) {
1442 /* Indirect call */
1443 if (kid->op_type == OP_METHOD_NAMED
1444 || kid->op_type == OP_METHOD)
1445 {
87d7fd28 1446 UNOP *newop;
cd06dffe
GS
1447
1448 if (kid->op_sibling || kid->op_next != kid) {
1449 yyerror("panic: unexpected optree near method call");
1450 break;
1451 }
1452
87d7fd28 1453 NewOp(1101, newop, 1, UNOP);
349fd7b7
GS
1454 newop->op_type = OP_RV2CV;
1455 newop->op_ppaddr = PL_ppaddr[OP_RV2CV];
87d7fd28
GS
1456 newop->op_first = Nullop;
1457 newop->op_next = (OP*)newop;
1458 kid->op_sibling = (OP*)newop;
349fd7b7 1459 newop->op_private |= OPpLVAL_INTRO;
cd06dffe
GS
1460 break;
1461 }
1c846c1f 1462
cd06dffe
GS
1463 if (kid->op_type != OP_RV2CV)
1464 Perl_croak(aTHX_
1465 "panic: unexpected lvalue entersub "
1466 "entry via type/targ %ld:%ld",
1467 (long)kid->op_type,kid->op_targ);
1468 kid->op_private |= OPpLVAL_INTRO;
1469 break; /* Postpone until runtime */
1470 }
1471
1472 okid = kid;
1473 kid = kUNOP->op_first;
1474 if (kid->op_type == OP_NULL && kid->op_targ == OP_RV2SV)
1475 kid = kUNOP->op_first;
1476 if (kid->op_type == OP_NULL)
1477 Perl_croak(aTHX_
1478 "Unexpected constant lvalue entersub "
1479 "entry via type/targ %ld:%ld",
1480 (long)kid->op_type,kid->op_targ);
1481 if (kid->op_type != OP_GV) {
1482 /* Restore RV2CV to check lvalueness */
1483 restore_2cv:
1484 if (kid->op_next && kid->op_next != kid) { /* Happens? */
1485 okid->op_next = kid->op_next;
1486 kid->op_next = okid;
1487 }
1488 else
1489 okid->op_next = Nullop;
1490 okid->op_type = OP_RV2CV;
1491 okid->op_targ = 0;
1492 okid->op_ppaddr = PL_ppaddr[OP_RV2CV];
1493 okid->op_private |= OPpLVAL_INTRO;
1494 break;
1495 }
1496
638eceb6 1497 cv = GvCV(kGVOP_gv);
1c846c1f 1498 if (!cv)
cd06dffe
GS
1499 goto restore_2cv;
1500 if (CvLVALUE(cv))
1501 break;
1502 }
1503 }
79072805
LW
1504 /* FALL THROUGH */
1505 default:
a0d0e21e
LW
1506 nomod:
1507 /* grep, foreach, subcalls, refgen */
1508 if (type == OP_GREPSTART || type == OP_ENTERSUB || type == OP_REFGEN)
1509 break;
cea2e8a9 1510 yyerror(Perl_form(aTHX_ "Can't modify %s in %s",
638bc118 1511 (o->op_type == OP_NULL && (o->op_flags & OPf_SPECIAL)
cd06dffe
GS
1512 ? "do block"
1513 : (o->op_type == OP_ENTERSUB
1514 ? "non-lvalue subroutine call"
1515 : PL_op_desc[o->op_type])),
22c35a8c 1516 type ? PL_op_desc[type] : "local"));
11343788 1517 return o;
79072805 1518
a0d0e21e
LW
1519 case OP_PREINC:
1520 case OP_PREDEC:
1521 case OP_POW:
1522 case OP_MULTIPLY:
1523 case OP_DIVIDE:
1524 case OP_MODULO:
1525 case OP_REPEAT:
1526 case OP_ADD:
1527 case OP_SUBTRACT:
1528 case OP_CONCAT:
1529 case OP_LEFT_SHIFT:
1530 case OP_RIGHT_SHIFT:
1531 case OP_BIT_AND:
1532 case OP_BIT_XOR:
1533 case OP_BIT_OR:
1534 case OP_I_MULTIPLY:
1535 case OP_I_DIVIDE:
1536 case OP_I_MODULO:
1537 case OP_I_ADD:
1538 case OP_I_SUBTRACT:
11343788 1539 if (!(o->op_flags & OPf_STACKED))
a0d0e21e 1540 goto nomod;
3280af22 1541 PL_modcount++;
a0d0e21e
LW
1542 break;
1543
79072805 1544 case OP_COND_EXPR:
11343788 1545 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
463ee0b2 1546 mod(kid, type);
79072805
LW
1547 break;
1548
1549 case OP_RV2AV:
1550 case OP_RV2HV:
93af7a87 1551 if (!type && cUNOPo->op_first->op_type != OP_GV)
cea2e8a9 1552 Perl_croak(aTHX_ "Can't localize through a reference");
11343788 1553 if (type == OP_REFGEN && o->op_flags & OPf_PARENS) {
e6438c1a 1554 PL_modcount = RETURN_UNLIMITED_NUMBER;
11343788 1555 return o; /* Treat \(@foo) like ordinary list. */
748a9306
LW
1556 }
1557 /* FALL THROUGH */
79072805 1558 case OP_RV2GV:
5dc0d613 1559 if (scalar_mod_type(o, type))
3fe9a6f1 1560 goto nomod;
11343788 1561 ref(cUNOPo->op_first, o->op_type);
79072805 1562 /* FALL THROUGH */
79072805
LW
1563 case OP_ASLICE:
1564 case OP_HSLICE:
78f9721b
SM
1565 if (type == OP_LEAVESUBLV)
1566 o->op_private |= OPpMAYBE_LVSUB;
1567 /* FALL THROUGH */
1568 case OP_AASSIGN:
93a17b20
LW
1569 case OP_NEXTSTATE:
1570 case OP_DBSTATE:
a0d0e21e 1571 case OP_CHOMP:
e6438c1a 1572 PL_modcount = RETURN_UNLIMITED_NUMBER;
79072805 1573 break;
463ee0b2 1574 case OP_RV2SV:
11343788 1575 if (!type && cUNOPo->op_first->op_type != OP_GV)
cea2e8a9 1576 Perl_croak(aTHX_ "Can't localize through a reference");
aeea060c 1577 ref(cUNOPo->op_first, o->op_type);
463ee0b2 1578 /* FALL THROUGH */
79072805 1579 case OP_GV:
463ee0b2 1580 case OP_AV2ARYLEN:
3280af22 1581 PL_hints |= HINT_BLOCK_SCOPE;
463ee0b2 1582 case OP_SASSIGN:
bf4b1e52
GS
1583 case OP_ANDASSIGN:
1584 case OP_ORASSIGN:
8990e307 1585 case OP_AELEMFAST:
3280af22 1586 PL_modcount++;
8990e307
LW
1587 break;
1588
748a9306
LW
1589 case OP_PADAV:
1590 case OP_PADHV:
e6438c1a 1591 PL_modcount = RETURN_UNLIMITED_NUMBER;
5196be3e
MB
1592 if (type == OP_REFGEN && o->op_flags & OPf_PARENS)
1593 return o; /* Treat \(@foo) like ordinary list. */
1594 if (scalar_mod_type(o, type))
3fe9a6f1 1595 goto nomod;
78f9721b
SM
1596 if (type == OP_LEAVESUBLV)
1597 o->op_private |= OPpMAYBE_LVSUB;
748a9306
LW
1598 /* FALL THROUGH */
1599 case OP_PADSV:
3280af22 1600 PL_modcount++;
748a9306 1601 if (!type)
cea2e8a9 1602 Perl_croak(aTHX_ "Can't localize lexical variable %s",
2d8e6c8d 1603 SvPV(*av_fetch(PL_comppad_name, o->op_targ, 4), n_a));
463ee0b2
LW
1604 break;
1605
554b3eca 1606#ifdef USE_THREADS
2faa37cc 1607 case OP_THREADSV:
533c011a 1608 PL_modcount++; /* XXX ??? */
554b3eca
MB
1609 break;
1610#endif /* USE_THREADS */
1611
748a9306
LW
1612 case OP_PUSHMARK:
1613 break;
a0d0e21e 1614
69969c6f
SB
1615 case OP_KEYS:
1616 if (type != OP_SASSIGN)
1617 goto nomod;
5d82c453
GA
1618 goto lvalue_func;
1619 case OP_SUBSTR:
1620 if (o->op_private == 4) /* don't allow 4 arg substr as lvalue */
1621 goto nomod;
5f05dabc 1622 /* FALL THROUGH */
a0d0e21e 1623 case OP_POS:
463ee0b2 1624 case OP_VEC:
78f9721b
SM
1625 if (type == OP_LEAVESUBLV)
1626 o->op_private |= OPpMAYBE_LVSUB;
5d82c453 1627 lvalue_func:
11343788
MB
1628 pad_free(o->op_targ);
1629 o->op_targ = pad_alloc(o->op_type, SVs_PADMY);
5dc0d613 1630 assert(SvTYPE(PAD_SV(o->op_targ)) == SVt_NULL);
11343788
MB
1631 if (o->op_flags & OPf_KIDS)
1632 mod(cBINOPo->op_first->op_sibling, type);
463ee0b2 1633 break;
a0d0e21e 1634
463ee0b2
LW
1635 case OP_AELEM:
1636 case OP_HELEM:
11343788 1637 ref(cBINOPo->op_first, o->op_type);
68dc0745 1638 if (type == OP_ENTERSUB &&
5dc0d613
MB
1639 !(o->op_private & (OPpLVAL_INTRO | OPpDEREF)))
1640 o->op_private |= OPpLVAL_DEFER;
78f9721b
SM
1641 if (type == OP_LEAVESUBLV)
1642 o->op_private |= OPpMAYBE_LVSUB;
3280af22 1643 PL_modcount++;
463ee0b2
LW
1644 break;
1645
1646 case OP_SCOPE:
1647 case OP_LEAVE:
1648 case OP_ENTER:
78f9721b 1649 case OP_LINESEQ:
11343788
MB
1650 if (o->op_flags & OPf_KIDS)
1651 mod(cLISTOPo->op_last, type);
a0d0e21e
LW
1652 break;
1653
1654 case OP_NULL:
638bc118
GS
1655 if (o->op_flags & OPf_SPECIAL) /* do BLOCK */
1656 goto nomod;
1657 else if (!(o->op_flags & OPf_KIDS))
463ee0b2 1658 break;
11343788
MB
1659 if (o->op_targ != OP_LIST) {
1660 mod(cBINOPo->op_first, type);
a0d0e21e
LW
1661 break;
1662 }
1663 /* FALL THROUGH */
463ee0b2 1664 case OP_LIST:
11343788 1665 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
463ee0b2
LW
1666 mod(kid, type);
1667 break;
78f9721b
SM
1668
1669 case OP_RETURN:
1670 if (type != OP_LEAVESUBLV)
1671 goto nomod;
1672 break; /* mod()ing was handled by ck_return() */
463ee0b2 1673 }
78f9721b
SM
1674 if (type != OP_LEAVESUBLV)
1675 o->op_flags |= OPf_MOD;
a0d0e21e
LW
1676
1677 if (type == OP_AASSIGN || type == OP_SASSIGN)
11343788 1678 o->op_flags |= OPf_SPECIAL|OPf_REF;
a0d0e21e 1679 else if (!type) {
11343788
MB
1680 o->op_private |= OPpLVAL_INTRO;
1681 o->op_flags &= ~OPf_SPECIAL;
3280af22 1682 PL_hints |= HINT_BLOCK_SCOPE;
463ee0b2 1683 }
78f9721b
SM
1684 else if (type != OP_GREPSTART && type != OP_ENTERSUB
1685 && type != OP_LEAVESUBLV)
11343788
MB
1686 o->op_flags |= OPf_REF;
1687 return o;
463ee0b2
LW
1688}
1689
864dbfa3 1690STATIC bool
cea2e8a9 1691S_scalar_mod_type(pTHX_ OP *o, I32 type)
3fe9a6f1
PP
1692{
1693 switch (type) {
1694 case OP_SASSIGN:
5196be3e 1695 if (o->op_type == OP_RV2GV)
3fe9a6f1
PP
1696 return FALSE;
1697 /* FALL THROUGH */
1698 case OP_PREINC:
1699 case OP_PREDEC:
1700 case OP_POSTINC:
1701 case OP_POSTDEC:
1702 case OP_I_PREINC:
1703 case OP_I_PREDEC:
1704 case OP_I_POSTINC:
1705 case OP_I_POSTDEC:
1706 case OP_POW:
1707 case OP_MULTIPLY:
1708 case OP_DIVIDE:
1709 case OP_MODULO:
1710 case OP_REPEAT:
1711 case OP_ADD:
1712 case OP_SUBTRACT:
1713 case OP_I_MULTIPLY:
1714 case OP_I_DIVIDE:
1715 case OP_I_MODULO:
1716 case OP_I_ADD:
1717 case OP_I_SUBTRACT:
1718 case OP_LEFT_SHIFT:
1719 case OP_RIGHT_SHIFT:
1720 case OP_BIT_AND:
1721 case OP_BIT_XOR:
1722 case OP_BIT_OR:
1723 case OP_CONCAT:
1724 case OP_SUBST:
1725 case OP_TRANS:
49e9fbe6
GS
1726 case OP_READ:
1727 case OP_SYSREAD:
1728 case OP_RECV:
bf4b1e52
GS
1729 case OP_ANDASSIGN:
1730 case OP_ORASSIGN:
3fe9a6f1
PP
1731 return TRUE;
1732 default:
1733 return FALSE;
1734 }
1735}
1736
35cd451c 1737STATIC bool
cea2e8a9 1738S_is_handle_constructor(pTHX_ OP *o, I32 argnum)
35cd451c
GS
1739{
1740 switch (o->op_type) {
1741 case OP_PIPE_OP:
1742 case OP_SOCKPAIR:
1743 if (argnum == 2)
1744 return TRUE;
1745 /* FALL THROUGH */
1746 case OP_SYSOPEN:
1747 case OP_OPEN:
ded8aa31 1748 case OP_SELECT: /* XXX c.f. SelectSaver.pm */
35cd451c
GS
1749 case OP_SOCKET:
1750 case OP_OPEN_DIR:
1751 case OP_ACCEPT:
1752 if (argnum == 1)
1753 return TRUE;
1754 /* FALL THROUGH */
1755 default:
1756 return FALSE;
1757 }
1758}
1759
463ee0b2 1760OP *
864dbfa3 1761Perl_refkids(pTHX_ OP *o, I32 type)
463ee0b2
LW
1762{
1763 OP *kid;
11343788
MB
1764 if (o && o->op_flags & OPf_KIDS) {
1765 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
463ee0b2
LW
1766 ref(kid, type);
1767 }
11343788 1768 return o;
463ee0b2
LW
1769}
1770
1771OP *
864dbfa3 1772Perl_ref(pTHX_ OP *o, I32 type)
463ee0b2
LW
1773{
1774 OP *kid;
463ee0b2 1775
3280af22 1776 if (!o || PL_error_count)
11343788 1777 return o;
463ee0b2 1778
11343788 1779 switch (o->op_type) {
a0d0e21e 1780 case OP_ENTERSUB:
afebc493 1781 if ((type == OP_EXISTS || type == OP_DEFINED || type == OP_LOCK) &&
11343788
MB
1782 !(o->op_flags & OPf_STACKED)) {
1783 o->op_type = OP_RV2CV; /* entersub => rv2cv */
22c35a8c 1784 o->op_ppaddr = PL_ppaddr[OP_RV2CV];
11343788
MB
1785 assert(cUNOPo->op_first->op_type == OP_NULL);
1786 null(((LISTOP*)cUNOPo->op_first)->op_first); /* disable pushmark */
1787 o->op_flags |= OPf_SPECIAL;
8990e307
LW
1788 }
1789 break;
aeea060c 1790
463ee0b2 1791 case OP_COND_EXPR:
11343788 1792 for (kid = cUNOPo->op_first->op_sibling; kid; kid = kid->op_sibling)
463ee0b2
LW
1793 ref(kid, type);
1794 break;
8990e307 1795 case OP_RV2SV:
35cd451c
GS
1796 if (type == OP_DEFINED)
1797 o->op_flags |= OPf_SPECIAL; /* don't create GV */
11343788 1798 ref(cUNOPo->op_first, o->op_type);
4633a7c4
LW
1799 /* FALL THROUGH */
1800 case OP_PADSV:
5f05dabc 1801 if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
5dc0d613
MB
1802 o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1803 : type == OP_RV2HV ? OPpDEREF_HV
1804 : OPpDEREF_SV);
11343788 1805 o->op_flags |= OPf_MOD;
a0d0e21e 1806 }
8990e307 1807 break;
1c846c1f 1808
2faa37cc 1809 case OP_THREADSV:
a863c7d1
MB
1810 o->op_flags |= OPf_MOD; /* XXX ??? */
1811 break;
1812
463ee0b2
LW
1813 case OP_RV2AV:
1814 case OP_RV2HV:
aeea060c 1815 o->op_flags |= OPf_REF;
8990e307 1816 /* FALL THROUGH */
463ee0b2 1817 case OP_RV2GV:
35cd451c
GS
1818 if (type == OP_DEFINED)
1819 o->op_flags |= OPf_SPECIAL; /* don't create GV */
11343788 1820 ref(cUNOPo->op_first, o->op_type);
463ee0b2 1821 break;
8990e307 1822
463ee0b2
LW
1823 case OP_PADAV:
1824 case OP_PADHV:
aeea060c 1825 o->op_flags |= OPf_REF;
79072805 1826 break;
aeea060c 1827
8990e307 1828 case OP_SCALAR:
79072805 1829 case OP_NULL:
11343788 1830 if (!(o->op_flags & OPf_KIDS))
463ee0b2 1831 break;
11343788 1832 ref(cBINOPo->op_first, type);
79072805
LW
1833 break;
1834 case OP_AELEM:
1835 case OP_HELEM:
11343788 1836 ref(cBINOPo->op_first, o->op_type);
5f05dabc 1837 if (type == OP_RV2SV || type == OP_RV2AV || type == OP_RV2HV) {
5dc0d613
MB
1838 o->op_private |= (type == OP_RV2AV ? OPpDEREF_AV
1839 : type == OP_RV2HV ? OPpDEREF_HV
1840 : OPpDEREF_SV);
11343788 1841 o->op_flags |= OPf_MOD;
8990e307 1842 }
79072805
LW
1843 break;
1844
463ee0b2 1845 case OP_SCOPE:
79072805
LW
1846 case OP_LEAVE:
1847 case OP_ENTER:
8990e307 1848 case OP_LIST:
11343788 1849 if (!(o->op_flags & OPf_KIDS))
79072805 1850 break;
11343788 1851 ref(cLISTOPo->op_last, type);
79072805 1852 break;
a0d0e21e
LW
1853 default:
1854 break;
79072805 1855 }
11343788 1856 return scalar(o);
8990e307 1857
79072805
LW
1858}
1859
09bef843
SB
1860STATIC OP *
1861S_dup_attrlist(pTHX_ OP *o)
1862{
1863 OP *rop = Nullop;
1864
1865 /* An attrlist is either a simple OP_CONST or an OP_LIST with kids,
1866 * where the first kid is OP_PUSHMARK and the remaining ones
1867 * are OP_CONST. We need to push the OP_CONST values.
1868 */
1869 if (o->op_type == OP_CONST)
1870 rop = newSVOP(OP_CONST, o->op_flags, SvREFCNT_inc(cSVOPo->op_sv));
1871 else {
1872 assert((o->op_type == OP_LIST) && (o->op_flags & OPf_KIDS));
1873 for (o = cLISTOPo->op_first; o; o=o->op_sibling) {
1874 if (o->op_type == OP_CONST)
1875 rop = append_elem(OP_LIST, rop,
1876 newSVOP(OP_CONST, o->op_flags,
1877 SvREFCNT_inc(cSVOPo->op_sv)));
1878 }
1879 }
1880 return rop;
1881}
1882
1883STATIC void
1884S_apply_attrs(pTHX_ HV *stash, SV *target, OP *attrs)
1885{
09bef843
SB
1886 SV *stashsv;
1887
1888 /* fake up C<use attributes $pkg,$rv,@attrs> */
1889 ENTER; /* need to protect against side-effects of 'use' */
1890 SAVEINT(PL_expect);
1891 if (stash && HvNAME(stash))
1892 stashsv = newSVpv(HvNAME(stash), 0);
1893 else
1894 stashsv = &PL_sv_no;
e4783991 1895
09bef843 1896#define ATTRSMODULE "attributes"
e4783991
GS
1897
1898 Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
1899 newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1),
1900 Nullsv,
1901 prepend_elem(OP_LIST,
1902 newSVOP(OP_CONST, 0, stashsv),
1903 prepend_elem(OP_LIST,
1904 newSVOP(OP_CONST, 0,
1905 newRV(target)),
1906 dup_attrlist(attrs))));
09bef843
SB
1907 LEAVE;
1908}
1909
be3174d2
GS
1910void
1911Perl_apply_attrs_string(pTHX_ char *stashpv, CV *cv,
1912 char *attrstr, STRLEN len)
1913{
1914 OP *attrs = Nullop;
1915
1916 if (!len) {
1917 len = strlen(attrstr);
1918 }
1919
1920 while (len) {
1921 for (; isSPACE(*attrstr) && len; --len, ++attrstr) ;
1922 if (len) {
1923 char *sstr = attrstr;
1924 for (; !isSPACE(*attrstr) && len; --len, ++attrstr) ;
1925 attrs = append_elem(OP_LIST, attrs,
1926 newSVOP(OP_CONST, 0,
1927 newSVpvn(sstr, attrstr-sstr)));
1928 }
1929 }
1930
1931 Perl_load_module(aTHX_ PERL_LOADMOD_IMPORT_OPS,
1932 newSVpvn(ATTRSMODULE, sizeof(ATTRSMODULE)-1),
1933 Nullsv, prepend_elem(OP_LIST,
1934 newSVOP(OP_CONST, 0, newSVpv(stashpv,0)),
1935 prepend_elem(OP_LIST,
1936 newSVOP(OP_CONST, 0,
1937 newRV((SV*)cv)),
1938 attrs)));
1939}
1940
09bef843
SB
1941STATIC OP *
1942S_my_kid(pTHX_ OP *o, OP *attrs)
93a17b20
LW
1943{
1944 OP *kid;
93a17b20
LW
1945 I32 type;
1946
3280af22 1947 if (!o || PL_error_count)
11343788 1948 return o;
93a17b20 1949
11343788 1950 type = o->op_type;
93a17b20 1951 if (type == OP_LIST) {
11343788 1952 for (kid = cLISTOPo->op_first; kid; kid = kid->op_sibling)
09bef843 1953 my_kid(kid, attrs);
dab48698 1954 } else if (type == OP_UNDEF) {
7766148a 1955 return o;
77ca0c92
LW
1956 } else if (type == OP_RV2SV || /* "our" declaration */
1957 type == OP_RV2AV ||
1958 type == OP_RV2HV) { /* XXX does this let anything illegal in? */
0256094b
DM
1959 if (attrs) {
1960 GV *gv = cGVOPx_gv(cUNOPo->op_first);
1961 PL_in_my = FALSE;
1962 PL_in_my_stash = Nullhv;
1963 apply_attrs(GvSTASH(gv),
1964 (type == OP_RV2SV ? GvSV(gv) :
1965 type == OP_RV2AV ? (SV*)GvAV(gv) :
1966 type == OP_RV2HV ? (SV*)GvHV(gv) : (SV*)gv),
1967 attrs);
1968 }
192587c2 1969 o->op_private |= OPpOUR_INTRO;
77ca0c92 1970 return o;
dab48698 1971 } else if (type != OP_PADSV &&
93a17b20
LW
1972 type != OP_PADAV &&
1973 type != OP_PADHV &&
1974 type != OP_PUSHMARK)
1975 {
eb64745e
GS
1976 yyerror(Perl_form(aTHX_ "Can't declare %s in \"%s\"",
1977 PL_op_desc[o->op_type],
1978 PL_in_my == KEY_our ? "our" : "my"));
11343788 1979 return o;
93a17b20 1980 }
09bef843
SB
1981 else if (attrs && type != OP_PUSHMARK) {
1982 HV *stash;
1983 SV *padsv;
1984 SV **namesvp;
1985
eb64745e
GS
1986 PL_in_my = FALSE;
1987 PL_in_my_stash = Nullhv;
1988
09bef843
SB
1989 /* check for C<my Dog $spot> when deciding package */
1990 namesvp = av_fetch(PL_comppad_name, o->op_targ, FALSE);
1991 if (namesvp && *namesvp && SvOBJECT(*namesvp) && HvNAME(SvSTASH(*namesvp)))
1992 stash = SvSTASH(*namesvp);
1993 else
1994 stash = PL_curstash;
1995 padsv = PAD_SV(o->op_targ);
1996 apply_attrs(stash, padsv, attrs);
1997 }
11343788
MB
1998 o->op_flags |= OPf_MOD;
1999 o->op_private |= OPpLVAL_INTRO;
2000 return o;
93a17b20
LW
2001}
2002
2003OP *
09bef843
SB
2004Perl_my_attrs(pTHX_ OP *o, OP *attrs)
2005{
2006 if (o->op_flags & OPf_PARENS)
2007 list(o);
09bef843
SB
2008 if (attrs)
2009 SAVEFREEOP(attrs);
eb64745e
GS
2010 o = my_kid(o, attrs);
2011 PL_in_my = FALSE;
2012 PL_in_my_stash = Nullhv;
2013 return o;
09bef843
SB
2014}
2015
2016OP *
2017Perl_my(pTHX_ OP *o)
2018{
2019 return my_kid(o, Nullop);
2020}
2021
2022OP *
864dbfa3 2023Perl_sawparens(pTHX_ OP *o)
79072805
LW
2024{
2025 if (o)
2026 o->op_flags |= OPf_PARENS;
2027 return o;
2028}
2029
2030OP *
864dbfa3 2031Perl_bind_match(pTHX_ I32 type, OP *left, OP *right)
79072805 2032{
11343788 2033 OP *o;
79072805 2034
e476b1b5 2035 if (ckWARN(WARN_MISC) &&
599cee73
PM
2036 (left->op_type == OP_RV2AV ||
2037 left->op_type == OP_RV2HV ||
2038 left->op_type == OP_PADAV ||
2039 left->op_type == OP_PADHV)) {
22c35a8c 2040 char *desc = PL_op_desc[(right->op_type == OP_SUBST ||
599cee73
PM
2041 right->op_type == OP_TRANS)
2042 ? right->op_type : OP_MATCH];
dff6d3cd
GS
2043 const char *sample = ((left->op_type == OP_RV2AV ||
2044 left->op_type == OP_PADAV)
2045 ? "@array" : "%hash");
e476b1b5 2046 Perl_warner(aTHX_ WARN_MISC,
1c846c1f 2047 "Applying %s to %s will act on scalar(%s)",
599cee73 2048 desc, sample, sample);
2ae324a7
PP
2049 }
2050
de4bf5b3
G
2051 if (!(right->op_flags & OPf_STACKED) &&
2052 (right->op_type == OP_MATCH ||
79072805 2053 right->op_type == OP_SUBST ||
de4bf5b3 2054 right->op_type == OP_TRANS)) {
79072805 2055 right->op_flags |= OPf_STACKED;
d897a58d
G
2056 if (right->op_type != OP_MATCH &&
2057 ! (right->op_type == OP_TRANS &&
2058 right->op_private & OPpTRANS_IDENTICAL))
463ee0b2 2059 left = mod(left, right->op_type);
79072805 2060 if (right->op_type == OP_TRANS)
11343788 2061 o = newBINOP(OP_NULL, OPf_STACKED, scalar(left), right);
79072805 2062 else
11343788 2063 o = prepend_elem(right->op_type, scalar(left), right);
79072805 2064 if (type == OP_NOT)
11343788
MB
2065 return newUNOP(OP_NOT, 0, scalar(o));
2066 return o;
79072805
LW
2067 }
2068 else
2069 return bind_match(type, left,
2070 pmruntime(newPMOP(OP_MATCH, 0), right, Nullop));
2071}
2072
2073OP *
864dbfa3 2074Perl_invert(pTHX_ OP *o)
79072805 2075{
11343788
MB
2076 if (!o)
2077 return o;
79072805 2078 /* XXX need to optimize away NOT NOT here? Or do we let optimizer do it? */
11343788 2079 return newUNOP(OP_NOT, OPf_SPECIAL, scalar(o));
79072805
LW
2080}
2081
2082OP *
864dbfa3 2083Perl_scope(pTHX_ OP *o)
79072805
LW
2084{
2085 if (o) {
3280af22 2086 if (o->op_flags & OPf_PARENS || PERLDB_NOOPT || PL_tainting) {
463ee0b2
LW
2087 o = prepend_elem(OP_LINESEQ, newOP(OP_ENTER, 0), o);
2088 o->op_type = OP_LEAVE;
22c35a8c 2089 o->op_ppaddr = PL_ppaddr[OP_LEAVE];
463ee0b2
LW
2090 }
2091 else {
2092 if (o->op_type == OP_LINESEQ) {
2093 OP *kid;
2094 o->op_type = OP_SCOPE;
22c35a8c 2095 o->op_ppaddr = PL_ppaddr[OP_SCOPE];
c3ed7a6a
GS
2096 kid = ((LISTOP*)o)->op_first;
2097 if (kid->op_type == OP_NEXTSTATE || kid->op_type == OP_DBSTATE)
2098 null(kid);
463ee0b2
LW
2099 }
2100 else
748a9306 2101 o = newLISTOP(OP_SCOPE, 0, o, Nullop);
463ee0b2 2102 }
79072805
LW
2103 }
2104 return o;
2105}
2106
b3ac6de7 2107void
864dbfa3 2108Perl_save_hints(pTHX)
b3ac6de7 2109{
3280af22
NIS
2110 SAVEI32(PL_hints);
2111 SAVESPTR(GvHV(PL_hintgv));
2112 GvHV(PL_hintgv) = newHVhv(GvHV(PL_hintgv));
2113 SAVEFREESV(GvHV(PL_hintgv));
b3ac6de7
IZ
2114}
2115
a0d0e21e 2116int
864dbfa3 2117Perl_block_start(pTHX_ int full)
79072805 2118{
3280af22 2119 int retval = PL_savestack_ix;
b3ac6de7 2120
3280af22 2121 SAVEI32(PL_comppad_name_floor);
43d4d5c6
GS
2122 PL_comppad_name_floor = AvFILLp(PL_comppad_name);
2123 if (full)
2124 PL_comppad_name_fill = PL_comppad_name_floor;
2125 if (PL_comppad_name_floor < 0)
2126 PL_comppad_name_floor = 0;
3280af22
NIS
2127 SAVEI32(PL_min_intro_pending);
2128 SAVEI32(PL_max_intro_pending);
2129 PL_min_intro_pending = 0;
2130 SAVEI32(PL_comppad_name_fill);
2131 SAVEI32(PL_padix_floor);
2132 PL_padix_floor = PL_padix;
2133 PL_pad_reset_pending = FALSE;
b3ac6de7 2134 SAVEHINTS();
3280af22 2135 PL_hints &= ~HINT_BLOCK_SCOPE;
1c846c1f 2136 SAVESPTR(PL_compiling.cop_warnings);
0453d815 2137 if (! specialWARN(PL_compiling.cop_warnings)) {
599cee73
PM
2138 PL_compiling.cop_warnings = newSVsv(PL_compiling.cop_warnings) ;
2139 SAVEFREESV(PL_compiling.cop_warnings) ;
2140 }
ac27b0f5
NIS
2141 SAVESPTR(PL_compiling.cop_io);
2142 if (! specialCopIO(PL_compiling.cop_io)) {
2143 PL_compiling.cop_io = newSVsv(PL_compiling.cop_io) ;
2144 SAVEFREESV(PL_compiling.cop_io) ;
2145 }
a0d0e21e
LW
2146 return retval;
2147}
2148
2149OP*
864dbfa3 2150Perl_block_end(pTHX_ I32 floor, OP *seq)
a0d0e21e 2151{
3280af22 2152 int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
a0d0e21e 2153 OP* retval = scalarseq(seq);
a0d0e21e 2154 LEAVE_SCOPE(floor);
3280af22 2155 PL_pad_reset_pending = FALSE;
e24b16f9 2156 PL_compiling.op_private = PL_hints;
a0d0e21e 2157 if (needblockscope)
3280af22
NIS
2158 PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
2159 pad_leavemy(PL_comppad_name_fill);
2160 PL_cop_seqmax++;
a0d0e21e
LW
2161 return retval;
2162}
2163
76e3520e 2164STATIC OP *
cea2e8a9 2165S_newDEFSVOP(pTHX)
54b9620d
MB
2166{
2167#ifdef USE_THREADS
2168 OP *o = newOP(OP_THREADSV, 0);
2169 o->op_targ = find_threadsv("_");
2170 return o;
2171#else
3280af22 2172 return newSVREF(newGVOP(OP_GV, 0, PL_defgv));
54b9620d
MB
2173#endif /* USE_THREADS */
2174}
2175
a0d0e21e 2176void
864dbfa3 2177Perl_newPROG(pTHX_ OP *o)
a0d0e21e 2178{
3280af22 2179 if (PL_in_eval) {
b295d113
TH
2180 if (PL_eval_root)
2181 return;
faef0170
HS
2182 PL_eval_root = newUNOP(OP_LEAVEEVAL,
2183 ((PL_in_eval & EVAL_KEEPERR)
2184 ? OPf_SPECIAL : 0), o);
3280af22 2185 PL_eval_start = linklist(PL_eval_root);
7934575e
GS
2186 PL_eval_root->op_private |= OPpREFCOUNTED;
2187 OpREFCNT_set(PL_eval_root, 1);
3280af22
NIS
2188 PL_eval_root->op_next = 0;
2189 peep(PL_eval_start);
a0d0e21e
LW
2190 }
2191 else {
5dc0d613 2192 if (!o)
a0d0e21e 2193 return;
3280af22
NIS
2194 PL_main_root = scope(sawparens(scalarvoid(o)));
2195 PL_curcop = &PL_compiling;
2196 PL_main_start = LINKLIST(PL_main_root);
7934575e
GS
2197 PL_main_root->op_private |= OPpREFCOUNTED;
2198 OpREFCNT_set(PL_main_root, 1);
3280af22
NIS
2199 PL_main_root->op_next = 0;
2200 peep(PL_main_start);
2201 PL_compcv = 0;
3841441e 2202
4fdae800 2203 /* Register with debugger */
84902520 2204 if (PERLDB_INTER) {
864dbfa3 2205 CV *cv = get_cv("DB::postponed", FALSE);
3841441e
CS
2206 if (cv) {
2207 dSP;
924508f0 2208 PUSHMARK(SP);
cc49e20b 2209 XPUSHs((SV*)CopFILEGV(&PL_compiling));
3841441e 2210 PUTBACK;
864dbfa3 2211 call_sv((SV*)cv, G_DISCARD);
3841441e
CS
2212 }
2213 }
79072805 2214 }
79072805
LW
2215}
2216
2217OP *
864dbfa3 2218Perl_localize(pTHX_ OP *o, I32 lex)
79072805
LW
2219{
2220 if (o->op_flags & OPf_PARENS)
2221 list(o);
8990e307 2222 else {
599cee73 2223 if (ckWARN(WARN_PARENTHESIS) && PL_bufptr > PL_oldbufptr && PL_bufptr[-1] == ',') {
8990e307 2224 char *s;
fd400ab9 2225 for (s = PL_bufptr; *s && (isALNUM(*s) || UTF8_IS_CONTINUED(*s) || strchr("@$%, ",*s)); s++) ;
a0d0e21e 2226 if (*s == ';' || *s == '=')
eb64745e
GS
2227 Perl_warner(aTHX_ WARN_PARENTHESIS,
2228 "Parentheses missing around \"%s\" list",
2229 lex ? (PL_in_my == KEY_our ? "our" : "my") : "local");
8990e307
LW
2230 }
2231 }
93a17b20 2232 if (lex)
eb64745e 2233 o = my(o);
93a17b20 2234 else
eb64745e
GS
2235 o = mod(o, OP_NULL); /* a bit kludgey */
2236 PL_in_my = FALSE;
2237 PL_in_my_stash = Nullhv;
2238 return o;
79072805
LW
2239}
2240
2241OP *
864dbfa3 2242Perl_jmaybe(pTHX_ OP *o)
79072805
LW
2243{
2244 if (o->op_type == OP_LIST) {
554b3eca
MB
2245 OP *o2;
2246#ifdef USE_THREADS
2faa37cc 2247 o2 = newOP(OP_THREADSV, 0);
54b9620d 2248 o2->op_targ = find_threadsv(";");
554b3eca
MB
2249#else
2250 o2 = newSVREF(newGVOP(OP_GV, 0, gv_fetchpv(";", TRUE, SVt_PV))),
2251#endif /* USE_THREADS */
2252 o = convert(OP_JOIN, 0, prepend_elem(OP_LIST, o2, o));
79072805
LW
2253 }
2254 return o;
2255}
2256
2257OP *
864dbfa3 2258Perl_fold_constants(pTHX_ register OP *o)
79072805
LW
2259{
2260 register OP *curop;
2261 I32 type = o->op_type;
748a9306 2262 SV *sv;
79072805 2263
22c35a8c 2264 if (PL_opargs[type] & OA_RETSCALAR)
79072805 2265 scalar(o);
b162f9ea 2266 if (PL_opargs[type] & OA_TARGET && !o->op_targ)
ed6116ce 2267 o->op_targ = pad_alloc(type, SVs_PADTMP);
79072805 2268
eac055e9
GS
2269 /* integerize op, unless it happens to be C<-foo>.
2270 * XXX should pp_i_negate() do magic string negation instead? */
2271 if ((PL_opargs[type] & OA_OTHERINT) && (PL_hints & HINT_INTEGER)
2272 && !(type == OP_NEGATE && cUNOPo->op_first->op_type == OP_CONST
2273 && (cUNOPo->op_first->op_private & OPpCONST_BARE)))
2274 {
22c35a8c 2275 o->op_ppaddr = PL_ppaddr[type = ++(o->op_type)];
eac055e9 2276 }
85e6fe83 2277
22c35a8c 2278 if (!(PL_opargs[type] & OA_FOLDCONST))
79072805
LW
2279 goto nope;
2280
de939608 2281 switch (type) {
7a52d87a
GS
2282 case OP_NEGATE:
2283 /* XXX might want a ck_negate() for this */
2284 cUNOPo->op_first->op_private &= ~OPpCONST_STRICT;
2285 break;
de939608
CS
2286 case OP_SPRINTF:
2287 case OP_UCFIRST:
2288 case OP_LCFIRST:
2289 case OP_UC:
2290 case OP_LC:
69dcf70c
MB
2291 case OP_SLT:
2292 case OP_SGT:
2293 case OP_SLE:
2294 case OP_SGE:
2295 case OP_SCMP:
2296
de939608
CS
2297 if (o->op_private & OPpLOCALE)
2298 goto nope;
2299 }
2300
3280af22 2301 if (PL_error_count)
a0d0e21e
LW
2302 goto nope; /* Don't try to run w/ errors */
2303
79072805 2304 for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
11fa937b
GS
2305 if ((curop->op_type != OP_CONST ||
2306 (curop->op_private & OPpCONST_BARE)) &&
7a52d87a
GS
2307 curop->op_type != OP_LIST &&
2308 curop->op_type != OP_SCALAR &&
2309 curop->op_type != OP_NULL &&
2310 curop->op_type != OP_PUSHMARK)
2311 {
79072805
LW
2312 goto nope;
2313 }
2314 }
2315
2316 curop = LINKLIST(o);
2317 o->op_next = 0;
533c011a 2318 PL_op = curop;
cea2e8a9 2319 CALLRUNOPS(aTHX);
3280af22 2320 sv = *(PL_stack_sp--);
748a9306 2321 if (o->op_targ && sv == PAD_SV(o->op_targ)) /* grab pad temp? */
79072805 2322 pad_swipe(o->op_targ);
748a9306
LW
2323 else if (SvTEMP(sv)) { /* grab mortal temp? */
2324 (void)SvREFCNT_inc(sv);
2325 SvTEMP_off(sv);
85e6fe83 2326 }
79072805
LW
2327 op_free(o);
2328 if (type == OP_RV2GV)
b1cb66bf 2329 return newGVOP(OP_GV, 0, (GV*)sv);
748a9306 2330 else {
ee580363
GS
2331 /* try to smush double to int, but don't smush -2.0 to -2 */
2332 if ((SvFLAGS(sv) & (SVf_IOK|SVf_NOK|SVf_POK)) == SVf_NOK &&
2333 type != OP_NEGATE)
2334 {
28e5dec8
JH
2335#ifdef PERL_PRESERVE_IVUV
2336 /* Only bother to attempt to fold to IV if
2337 most operators will benefit */
2338 SvIV_please(sv);
2339#endif
748a9306
LW
2340 }
2341 return newSVOP(OP_CONST, 0, sv);
2342 }
aeea060c 2343
79072805 2344 nope:
22c35a8c 2345 if (!(PL_opargs[type] & OA_OTHERINT))
79072805 2346 return o;
79072805 2347
3280af22 2348 if (!(PL_hints & HINT_INTEGER)) {
4bb9f687
GS
2349 if (type == OP_MODULO
2350 || type == OP_DIVIDE
2351 || !(o->op_flags & OPf_KIDS))
2352 {
85e6fe83 2353 return o;
4bb9f687 2354 }
85e6fe83
LW
2355
2356 for (curop = ((UNOP*)o)->op_first; curop; curop = curop->op_sibling) {
2357 if (curop->op_type == OP_CONST) {
b1cb66bf 2358 if (SvIOK(((SVOP*)curop)->op_sv))
85e6fe83
LW
2359 continue;
2360 return o;
2361 }
22c35a8c 2362 if (PL_opargs[curop->op_type] & OA_RETINTEGER)
79072805
LW
2363 continue;
2364 return o;
2365 }
22c35a8c 2366 o->op_ppaddr = PL_ppaddr[++(o->op_type)];
79072805
LW
2367 }
2368
79072805
LW
2369 return o;
2370}
2371
2372OP *
864dbfa3 2373Perl_gen_constant_list(pTHX_ register OP *o)
79072805
LW
2374{
2375 register OP *curop;
3280af22 2376 I32 oldtmps_floor = PL_tmps_floor;
79072805 2377
a0d0e21e 2378 list(o);
3280af22 2379 if (PL_error_count)
a0d0e21e
LW
2380 return o; /* Don't attempt to run with errors */
2381
533c011a 2382 PL_op = curop = LINKLIST(o);
a0d0e21e 2383 o->op_next = 0;
7d4045d4 2384 peep(curop);
cea2e8a9
GS
2385 pp_pushmark();
2386 CALLRUNOPS(aTHX);
533c011a 2387 PL_op = curop;
cea2e8a9 2388 pp_anonlist();
3280af22 2389 PL_tmps_floor = oldtmps_floor;
79072805
LW
2390
2391 o->op_type = OP_RV2AV;
22c35a8c 2392 o->op_ppaddr = PL_ppaddr[OP_RV2AV];
79072805 2393 curop = ((UNOP*)o)->op_first;
3280af22 2394 ((UNOP*)o)->op_first = newSVOP(OP_CONST, 0, SvREFCNT_inc(*PL_stack_sp--));
79072805 2395 op_free(curop);
79072805
LW
2396 linklist(o);
2397 return list(o);
2398}
2399
2400OP *
864dbfa3 2401Perl_convert(pTHX_ I32 type, I32 flags, OP *o)
79072805 2402{
11343788
MB
2403 if (!o || o->op_type != OP_LIST)
2404 o = newLISTOP(OP_LIST, 0, o, Nullop);
748a9306 2405 else
5dc0d613 2406 o->op_flags &= ~OPf_WANT;
79072805 2407
22c35a8c 2408 if (!(PL_opargs[type] & OA_MARK))
11343788 2409 null(cLISTOPo->op_first);
8990e307 2410
11343788 2411 o->op_type = type;
22c35a8c 2412 o->op_ppaddr = PL_ppaddr[type];
11343788 2413 o->op_flags |= flags;
79072805 2414
11343788
MB
2415 o = CHECKOP(type, o);
2416 if (o->op_type != type)
2417 return o;
79072805 2418
11343788 2419 return fold_constants(o);
79072805
LW
2420}
2421
2422/* List constructors */
2423
2424OP *
864dbfa3 2425Perl_append_elem(pTHX_ I32 type, OP *first, OP *last)
79072805
LW
2426{
2427 if (!first)
2428 return last;
8990e307
LW
2429
2430 if (!last)
79072805 2431 return first;
8990e307 2432
155aba94
GS
2433 if (first->op_type != type
2434 || (type == OP_LIST && (first->op_flags & OPf_PARENS)))
2435 {
2436 return newLISTOP(type, 0, first, last);
2437 }
79072805 2438
a0d0e21e
LW
2439 if (first->op_flags & OPf_KIDS)
2440 ((LISTOP*)first)->op_last->op_sibling = last;
2441 else {
2442 first->op_flags |= OPf_KIDS;
2443 ((LISTOP*)first)->op_first = last;
2444 }
2445 ((LISTOP*)first)->op_last = last;
a0d0e21e 2446 return first;
79072805
LW
2447}
2448
2449OP *
864dbfa3 2450Perl_append_list(pTHX_ I32 type, LISTOP *first, LISTOP *last)
79072805
LW
2451{
2452 if (!first)
2453 return (OP*)last;
8990e307
LW
2454
2455 if (!last)
79072805 2456 return (OP*)first;
8990e307
LW
2457
2458 if (first->op_type != type)
79072805 2459 return prepend_elem(type, (OP*)first, (OP*)last);
8990e307
LW
2460
2461 if (last->op_type != type)
79072805
LW
2462 return append_elem(type, (OP*)first, (OP*)last);
2463
2464 first->op_last->op_sibling = last->op_first;
2465 first->op_last = last->op_last;
117dada2 2466 first->op_flags |= (last->op_flags & OPf_KIDS);
1c846c1f 2467
b7dc083c
NIS
2468#ifdef PL_OP_SLAB_ALLOC
2469#else
1c846c1f 2470 Safefree(last);
b7dc083c 2471#endif
79072805
LW
2472 return (OP*)first;
2473}
2474
2475OP *
864dbfa3 2476Perl_prepend_elem(pTHX_ I32 type, OP *first, OP *last)
79072805
LW
2477{
2478 if (!first)
2479 return last;
8990e307
LW
2480
2481 if (!last)
79072805 2482 return first;
8990e307
LW
2483
2484 if (last->op_type == type) {
2485 if (type == OP_LIST) { /* already a PUSHMARK there */
2486 first->op_sibling = ((LISTOP*)last)->op_first->op_sibling;
2487 ((LISTOP*)last)->op_first->op_sibling = first;
36a5d4ba
DC
2488 if (!(first->op_flags & OPf_PARENS))
2489 last->op_flags &= ~OPf_PARENS;
8990e307
LW
2490 }
2491 else {
2492 if (!(last->op_flags & OPf_KIDS)) {
2493 ((LISTOP*)last)->op_last = first;
2494 last->op_flags |= OPf_KIDS;
2495 }
2496 first->op_sibling = ((LISTOP*)last)->op_first;
2497 ((LISTOP*)last)->op_first = first;
79072805 2498 }
117dada2 2499 last->op_flags |= OPf_KIDS;
79072805
LW
2500 return last;
2501 }
2502
2503 return newLISTOP(type, 0, first, last);
2504}
2505
2506/* Constructors */
2507
2508OP *
864dbfa3 2509Perl_newNULLLIST(pTHX)
79072805 2510{
8990e307
LW
2511 return newOP(OP_STUB, 0);
2512}
2513
2514OP *
864dbfa3 2515Perl_force_list(pTHX_ OP *o)
8990e307 2516{
11343788
MB
2517 if (!o || o->op_type != OP_LIST)
2518 o = newLISTOP(OP_LIST, 0, o, Nullop);
2519 null(o);
2520 return o;
79072805
LW
2521}
2522
2523OP *
864dbfa3 2524Perl_newLISTOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
79072805
LW
2525{
2526 LISTOP *listop;
2527
b7dc083c 2528 NewOp(1101, listop, 1, LISTOP);
79072805
LW
2529
2530 listop->op_type = type;
22c35a8c 2531 listop->op_ppaddr = PL_ppaddr[type];
117dada2
SM
2532 if (first || last)
2533 flags |= OPf_KIDS;
79072805 2534 listop->op_flags = flags;
79072805
LW
2535
2536 if (!last && first)
2537 last = first;
2538 else if (!first && last)
2539 first = last;
8990e307
LW
2540 else if (first)
2541 first->op_sibling = last;
79072805
LW
2542 listop->op_first = first;
2543 listop->op_last = last;
8990e307
LW
2544 if (type == OP_LIST) {
2545 OP* pushop;
2546 pushop = newOP(OP_PUSHMARK, 0);
2547 pushop->op_sibling = first;
2548 listop->op_first = pushop;
2549 listop->op_flags |= OPf_KIDS;
2550 if (!last)
2551 listop->op_last = pushop;
2552 }
79072805
LW
2553
2554 return (OP*)listop;
2555}
2556
2557OP *
864dbfa3 2558Perl_newOP(pTHX_ I32 type, I32 flags)
79072805 2559{
11343788 2560 OP *o;
b7dc083c 2561 NewOp(1101, o, 1, OP);
11343788 2562 o->op_type = type;
22c35a8c 2563 o->op_ppaddr = PL_ppaddr[type];
11343788 2564 o->op_flags = flags;
79072805 2565
11343788
MB
2566 o->op_next = o;
2567 o->op_private = 0 + (flags >> 8);
22c35a8c 2568 if (PL_opargs[type] & OA_RETSCALAR)
11343788 2569 scalar(o);
22c35a8c 2570 if (PL_opargs[type] & OA_TARGET)
11343788
MB
2571 o->op_targ = pad_alloc(type, SVs_PADTMP);
2572 return CHECKOP(type, o);
79072805
LW
2573}
2574
2575OP *
864dbfa3 2576Perl_newUNOP(pTHX_ I32 type, I32 flags, OP *first)
79072805
LW
2577{
2578 UNOP *unop;
2579
93a17b20 2580 if (!first)
aeea060c 2581 first = newOP(OP_STUB, 0);
22c35a8c 2582 if (PL_opargs[type] & OA_MARK)
8990e307 2583 first = force_list(first);
93a17b20 2584
b7dc083c 2585 NewOp(1101, unop, 1, UNOP);
79072805 2586 unop->op_type = type;
22c35a8c 2587 unop->op_ppaddr = PL_ppaddr[type];
79072805
LW
2588 unop->op_first = first;
2589 unop->op_flags = flags | OPf_KIDS;
c07a80fd 2590 unop->op_private = 1 | (flags >> 8);
e50aee73 2591 unop = (UNOP*) CHECKOP(type, unop);
79072805
LW
2592 if (unop->op_next)
2593 return (OP*)unop;
2594
a0d0e21e 2595 return fold_constants((OP *) unop);
79072805
LW
2596}
2597
2598OP *
864dbfa3 2599Perl_newBINOP(pTHX_ I32 type, I32 flags, OP *first, OP *last)
79072805
LW
2600{
2601 BINOP *binop;
b7dc083c 2602 NewOp(1101, binop, 1, BINOP);
79072805
LW
2603
2604 if (!first)
2605 first = newOP(OP_NULL, 0);
2606
2607 binop->op_type = type;
22c35a8c 2608 binop->op_ppaddr = PL_ppaddr[type];
79072805
LW
2609 binop->op_first = first;
2610 binop->op_flags = flags | OPf_KIDS;
2611 if (!last) {
2612 last = first;
c07a80fd 2613 binop->op_private = 1 | (flags >> 8);
79072805
LW
2614 }
2615 else {
c07a80fd 2616 binop->op_private = 2 | (flags >> 8);
79072805
LW
2617 first->op_sibling = last;
2618 }
2619
e50aee73 2620 binop = (BINOP*)CHECKOP(type, binop);
b162f9ea 2621 if (binop->op_next || binop->op_type != type)
79072805
LW
2622 return (OP*)binop;
2623
7284ab6f 2624 binop->op_last = binop->op_first->op_sibling;
79072805 2625
a0d0e21e 2626 return fold_constants((OP *)binop);
79072805
LW
2627}
2628
a0ed51b3
LW
2629static int
2630utf8compare(const void *a, const void *b)
2631{
2632 int i;
2633 for (i = 0; i < 10; i++) {
2634 if ((*(U8**)a)[i] < (*(U8**)b)[i])
2635 return -1;
2636 if ((*(U8**)a)[i] > (*(U8**)b)[i])
2637 return 1;
2638 }
2639 return 0;
2640}
2641
79072805 2642OP *
864dbfa3 2643Perl_pmtrans(pTHX_ OP *o, OP *expr, OP *repl)
79072805 2644{
79072805
LW
2645 SV *tstr = ((SVOP*)expr)->op_sv;
2646 SV *rstr = ((SVOP*)repl)->op_sv;
463ee0b2
LW
2647 STRLEN tlen;
2648 STRLEN rlen;
9b877dbb
IH
2649 U8 *t = (U8*)SvPV(tstr, tlen);
2650 U8 *r = (U8*)SvPV(rstr, rlen);
79072805
LW
2651 register I32 i;
2652 register I32 j;
a0ed51b3 2653 I32 del;
79072805 2654 I32 complement;
5d06d08e 2655 I32 squash;
9b877dbb 2656 I32 grows = 0;
79072805
LW
2657 register short *tbl;
2658
11343788 2659 complement = o->op_private & OPpTRANS_COMPLEMENT;
a0ed51b3 2660 del = o->op_private & OPpTRANS_DELETE;
5d06d08e 2661 squash = o->op_private & OPpTRANS_SQUASH;
1c846c1f 2662
036b4402
GS
2663 if (SvUTF8(tstr))
2664 o->op_private |= OPpTRANS_FROM_UTF;
1c846c1f
NIS
2665
2666 if (SvUTF8(rstr))
036b4402 2667 o->op_private |= OPpTRANS_TO_UTF;
79072805 2668
a0ed51b3 2669 if (o->op_private & (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF)) {
79cb57f6 2670 SV* listsv = newSVpvn("# comment\n",10);
a0ed51b3
LW
2671 SV* transv = 0;
2672 U8* tend = t + tlen;
2673 U8* rend = r + rlen;
ba210ebe 2674 STRLEN ulen;
a0ed51b3
LW
2675 U32 tfirst = 1;
2676 U32 tlast = 0;
2677 I32 tdiff;
2678 U32 rfirst = 1;
2679 U32 rlast = 0;
2680 I32 rdiff;
2681 I32 diff;
2682 I32 none = 0;
2683 U32 max = 0;
2684 I32 bits;
a0ed51b3
LW
2685 I32 havefinal = 0;
2686 U32 final;
a0ed51b3
LW
2687 I32 from_utf = o->op_private & OPpTRANS_FROM_UTF;
2688 I32 to_utf = o->op_private & OPpTRANS_TO_UTF;
9b877dbb
IH
2689 U8* tsave = from_utf ? NULL : trlist_upgrade(&t, &tend);
2690 U8* rsave = to_utf ? NULL : trlist_upgrade(&r, &rend);
a0ed51b3
LW
2691
2692 if (complement) {
ad391ad9 2693 U8 tmpbuf[UTF8_MAXLEN+1];
a0ed51b3
LW
2694 U8** cp;
2695 UV nextmin = 0;
2696 New(1109, cp, tlen, U8*);
2697 i = 0;
79cb57f6 2698 transv = newSVpvn("",0);
a0ed51b3
LW
2699 while (t < tend) {
2700 cp[i++] = t;
2701 t += UTF8SKIP(t);
455d824a 2702 if (t < tend && *t == 0xff) {
a0ed51b3
LW
2703 t++;
2704 t += UTF8SKIP(t);
2705 }
2706 }
2707 qsort(cp, i, sizeof(U8*), utf8compare);
2708 for (j = 0; j < i; j++) {
2709 U8 *s = cp[j];
455d824a 2710 I32 cur = j < i - 1 ? cp[j+1] - s : tend - s;
9041c2e3
NIS
2711 /* CHECKME: Use unicode code points for ranges - needs more thought ... NI-S */
2712 UV val = utf8n_to_uvuni(s, cur, &ulen, 0);
a0ed51b3
LW
2713 s += ulen;
2714 diff = val - nextmin;
2715 if (diff > 0) {
9041c2e3 2716 t = uvuni_to_utf8(tmpbuf,nextmin);
dfe13c55 2717 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
a0ed51b3 2718 if (diff > 1) {
9041c2e3 2719 t = uvuni_to_utf8(tmpbuf, val - 1);
a0ed51b3 2720 sv_catpvn(transv, "\377", 1);
dfe13c55 2721 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
a0ed51b3
LW
2722 }
2723 }
455d824a 2724 if (s < tend && *s == 0xff)
9041c2e3 2725 val = utf8n_to_uvuni(s+1, cur - 1, &ulen, 0);
a0ed51b3
LW
2726 if (val >= nextmin)
2727 nextmin = val + 1;
2728 }
9041c2e3 2729 t = uvuni_to_utf8(tmpbuf,nextmin);
dfe13c55 2730 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
9041c2e3 2731 t = uvuni_to_utf8(tmpbuf, 0x7fffffff);
a0ed51b3 2732 sv_catpvn(transv, "\377", 1);
dfe13c55
GS
2733 sv_catpvn(transv, (char*)tmpbuf, t - tmpbuf);
2734 t = (U8*)SvPVX(transv);
a0ed51b3
LW
2735 tlen = SvCUR(transv);
2736 tend = t + tlen;
455d824a 2737 Safefree(cp);
a0ed51b3
LW
2738 }
2739 else if (!rlen && !del) {
2740 r = t; rlen = tlen; rend = tend;
4757a243
LW
2741 }
2742 if (!squash) {
12ae5dfc
JH
2743 if (t == r ||
2744 (tlen == rlen && memEQ((char *)t, (char *)r, tlen)))
01ec43d0 2745 {
4757a243 2746 o->op_private |= OPpTRANS_IDENTICAL;
01ec43d0 2747 }
a0ed51b3
LW
2748 }
2749
2750 while (t < tend || tfirst <= tlast) {
2751 /* see if we need more "t" chars */
2752 if (tfirst > tlast) {
9041c2e3 2753 tfirst = (I32)utf8n_to_uvuni(t, tend - t, &ulen, 0);
a0ed51b3
LW
2754 t += ulen;
2755 if (t < tend && *t == 0xff) { /* illegal utf8 val indicates range */
ba210ebe 2756 t++;
9041c2e3 2757 tlast = (I32)utf8n_to_uvuni(t, tend - t, &ulen, 0);
a0ed51b3
LW
2758 t += ulen;
2759 }
2760 else
2761 tlast = tfirst;
2762 }
2763
2764 /* now see if we need more "r" chars */
2765 if (rfirst > rlast) {
2766 if (r < rend) {
9041c2e3 2767 rfirst = (I32)utf8n_to_uvuni(r, rend - r, &ulen, 0);
a0ed51b3
LW
2768 r += ulen;
2769 if (r < rend && *r == 0xff) { /* illegal utf8 val indicates range */
ba210ebe 2770 r++;
9041c2e3 2771 rlast = (I32)utf8n_to_uvuni(r, rend - r, &ulen, 0);
a0ed51b3
LW
2772 r += ulen;
2773 }
2774 else
2775 rlast = rfirst;
2776 }
2777 else {
2778 if (!havefinal++)
2779 final = rlast;
2780 rfirst = rlast = 0xffffffff;
2781 }
2782 }
2783
2784 /* now see which range will peter our first, if either. */
2785 tdiff = tlast - tfirst;
2786 rdiff = rlast - rfirst;
2787
2788 if (tdiff <= rdiff)
2789 diff = tdiff;
2790 else
2791 diff = rdiff;
2792
2793 if (rfirst == 0xffffffff) {
2794 diff = tdiff; /* oops, pretend rdiff is infinite */
2795 if (diff > 0)
894356b3
GS
2796 Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\tXXXX\n",
2797 (long)tfirst, (long)tlast);
a0ed51b3 2798 else
894356b3 2799 Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\tXXXX\n", (long)tfirst);
a0ed51b3
LW
2800 }
2801 else {
2802 if (diff > 0)
894356b3
GS
2803 Perl_sv_catpvf(aTHX_ listsv, "%04lx\t%04lx\t%04lx\n",
2804 (long)tfirst, (long)(tfirst + diff),
2805 (long)rfirst);
a0ed51b3 2806 else
894356b3
GS
2807 Perl_sv_catpvf(aTHX_ listsv, "%04lx\t\t%04lx\n",
2808 (long)tfirst, (long)rfirst);
a0ed51b3
LW
2809
2810 if (rfirst + diff > max)
2811 max = rfirst + diff;
2812 rfirst += diff + 1;
9b877dbb
IH
2813 if (!grows)
2814 grows = (UNISKIP(tfirst) < UNISKIP(rfirst));
a0ed51b3
LW
2815 }
2816 tfirst += diff + 1;
2817 }
2818
2819 none = ++max;
2820 if (del)
2821 del = ++max;
2822
2823 if (max > 0xffff)
2824 bits = 32;
2825 else if (max > 0xff)
2826 bits = 16;
2827 else
2828 bits = 8;
2829
455d824a 2830 Safefree(cPVOPo->op_pv);
a0ed51b3
LW
2831 cSVOPo->op_sv = (SV*)swash_init("utf8", "", listsv, bits, none);
2832 SvREFCNT_dec(listsv);
2833 if (transv)
2834 SvREFCNT_dec(transv);
2835
2836 if (!del && havefinal)
b448e4fe
JH
2837 (void)hv_store((HV*)SvRV((cSVOPo->op_sv)), "FINAL", 5,
2838 newSVuv((UV)final), 0);
a0ed51b3 2839
9b877dbb 2840 if (grows)
a0ed51b3
LW
2841 o->op_private |= OPpTRANS_GROWS;
2842
9b877dbb
IH
2843 if (tsave)
2844 Safefree(tsave);
2845 if (rsave)
2846 Safefree(rsave);
2847
a0ed51b3
LW
2848 op_free(expr);
2849 op_free(repl);
2850 return o;
2851 }
2852
2853 tbl = (short*)cPVOPo->op_pv;
79072805
LW
2854 if (complement) {
2855 Zero(tbl, 256, short);
2856 for (i = 0; i < tlen; i++)
ec49126f 2857 tbl[t[i]] = -1;
79072805
LW
2858 for (i = 0, j = 0; i < 256; i++) {
2859 if (!tbl[i]) {
2860 if (j >= rlen) {
a0ed51b3 2861 if (del)
79072805
LW
2862 tbl[i] = -2;
2863 else if (rlen)
ec49126f 2864 tbl[i] = r[j-1];
79072805
LW
2865 else
2866 tbl[i] = i;
2867 }
9b877dbb
IH
2868 else {
2869 if (i < 128 && r[j] >= 128)
2870 grows = 1;
ec49126f 2871 tbl[i] = r[j++];
9b877dbb 2872 }
79072805
LW
2873 }
2874 }
8973db79
JH
2875 if (!del) {
2876 if (j >= rlen)
2877 j = rlen - 1;
2878 else
2879 cPVOPo->op_pv = (char*)Renew(tbl, 0x101+rlen-j, short);
2880 tbl[0x100] = rlen - j;
2881 for (i=0; i < rlen - j; i++)
2882 tbl[0x101+i] = r[j+i];
2883 }
79072805
LW
2884 }
2885 else {
a0ed51b3 2886 if (!rlen && !del) {
79072805 2887 r = t; rlen = tlen;
5d06d08e 2888 if (!squash)
4757a243 2889 o->op_private |= OPpTRANS_IDENTICAL;
79072805
LW
2890 }
2891 for (i = 0; i < 256; i++)
2892 tbl[i] = -1;
2893 for (i = 0, j = 0; i < tlen; i++,j++) {
2894 if (j >= rlen) {
a0ed51b3 2895 if (del) {
ec49126f
PP
2896 if (tbl[t[i]] == -1)
2897 tbl[t[i]] = -2;
79072805
LW
2898 continue;
2899 }
2900 --j;
2901 }
9b877dbb
IH
2902 if (tbl[t[i]] == -1) {
2903 if (t[i] < 128 && r[j] >= 128)
2904 grows = 1;
ec49126f 2905 tbl[t[i]] = r[j];
9b877dbb 2906 }
79072805
LW
2907 }
2908 }
9b877dbb
IH
2909 if (grows)
2910 o->op_private |= OPpTRANS_GROWS;
79072805
LW
2911 op_free(expr);
2912 op_free(repl);
2913
11343788 2914 return o;
79072805
LW
2915}
2916
2917OP *
864dbfa3 2918Perl_newPMOP(pTHX_ I32 type, I32 flags)
79072805
LW
2919{
2920 PMOP *pmop;
2921
b7dc083c 2922 NewOp(1101, pmop, 1, PMOP);
79072805 2923 pmop->op_type = type;
22c35a8c 2924 pmop->op_ppaddr = PL_ppaddr[type];
79072805 2925 pmop->op_flags = flags;
c07a80fd 2926 pmop->op_private = 0 | (flags >> 8);
79072805 2927
3280af22 2928 if (PL_hints & HINT_RE_TAINT)
b3eb6a9b 2929 pmop->op_pmpermflags |= PMf_RETAINT;
3280af22 2930 if (PL_hints & HINT_LOCALE)
b3eb6a9b
GS
2931 pmop->op_pmpermflags |= PMf_LOCALE;
2932 pmop->op_pmflags = pmop->op_pmpermflags;
36477c24 2933
79072805 2934 /* link into pm list */
3280af22
NIS
2935 if (type != OP_TRANS && PL_curstash) {
2936 pmop->op_pmnext = HvPMROOT(PL_curstash);
2937 HvPMROOT(PL_curstash) = pmop;
79072805
LW
2938 }
2939
2940 return (OP*)pmop;
2941}
2942
2943OP *
864dbfa3 2944Perl_pmruntime(pTHX_ OP *o, OP *expr, OP *repl)
79072805
LW
2945{
2946 PMOP *pm;
2947 LOGOP *rcop;
ce862d02 2948 I32 repl_has_vars = 0;
79072805 2949
11343788
MB
2950 if (o->op_type == OP_TRANS)
2951 return pmtrans(o, expr, repl);
79072805 2952
3280af22 2953 PL_hints |= HINT_BLOCK_SCOPE;
11343788 2954 pm = (PMOP*)o;
79072805
LW
2955
2956 if (expr->op_type == OP_CONST) {
463ee0b2 2957 STRLEN plen;
79072805 2958 SV *pat = ((SVOP*)expr)->op_sv;
463ee0b2 2959 char *p = SvPV(pat, plen);
11343788 2960 if ((o->op_flags & OPf_SPECIAL) && strEQ(p, " ")) {
93a17b20 2961 sv_setpvn(pat, "\\s+", 3);
463ee0b2 2962 p = SvPV(pat, plen);
79072805
LW
2963 pm->op_pmflags |= PMf_SKIPWHITE;
2964 }
1fd7b382 2965 if ((PL_hints & HINT_UTF8) || DO_UTF8(pat))
7e2040f0 2966 pm->op_pmdynflags |= PMdf_UTF8;
cea2e8a9 2967 pm->op_pmregexp = CALLREGCOMP(aTHX_ p, p + plen, pm);
aeea060c 2968 if (strEQ("\\s+", pm->op_pmregexp->precomp))
85e6fe83 2969 pm->op_pmflags |= PMf_WHITE;
79072805
LW
2970 op_free(expr);
2971 }
2972 else {
393fec97
GS
2973 if (PL_hints & HINT_UTF8)
2974 pm->op_pmdynflags |= PMdf_UTF8;
3280af22 2975 if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL))
1c846c1f 2976 expr = newUNOP((!(PL_hints & HINT_RE_EVAL)
2cd61cdb
IZ
2977 ? OP_REGCRESET
2978 : OP_REGCMAYBE),0,expr);
463ee0b2 2979
b7dc083c 2980 NewOp(1101, rcop, 1, LOGOP);
79072805 2981 rcop->op_type = OP_REGCOMP;
22c35a8c 2982 rcop->op_ppaddr = PL_ppaddr[OP_REGCOMP];
79072805 2983 rcop->op_first = scalar(expr);
1c846c1f 2984 rcop->op_flags |= ((PL_hints & HINT_RE_EVAL)
2cd61cdb
IZ
2985 ? (OPf_SPECIAL | OPf_KIDS)
2986 : OPf_KIDS);
79072805 2987 rcop->op_private = 1;
11343788 2988 rcop->op_other = o;
79072805
LW
2989
2990 /* establish postfix order */
3280af22 2991 if (pm->op_pmflags & PMf_KEEP || !(PL_hints & HINT_RE_EVAL)) {
463ee0b2
LW
2992 LINKLIST(expr);
2993 rcop->op_next = expr;
2994 ((UNOP*)expr)->op_first->op_next = (OP*)rcop;
2995 }
2996 else {
2997 rcop->op_next = LINKLIST(expr);
2998 expr->op_next = (OP*)rcop;
2999 }
79072805 3000
11343788 3001 prepend_elem(o->op_type, scalar((OP*)rcop), o);
79072805
LW
3002 }
3003
3004 if (repl) {
748a9306 3005 OP *curop;
0244c3a4 3006 if (pm->op_pmflags & PMf_EVAL) {
748a9306 3007 curop = 0;
57843af0
GS
3008 if (CopLINE(PL_curcop) < PL_multi_end)
3009 CopLINE_set(PL_curcop, PL_multi_end);
0244c3a4 3010 }
554b3eca 3011#ifdef USE_THREADS
2faa37cc 3012 else if (repl->op_type == OP_THREADSV
554b3eca 3013 && strchr("&`'123456789+",
533c011a 3014 PL_threadsv_names[repl->op_targ]))
554b3eca
MB
3015 {
3016 curop = 0;
3017 }
3018#endif /* USE_THREADS */
748a9306
LW
3019 else if (repl->op_type == OP_CONST)
3020 curop = repl;
79072805 3021 else {
79072805
LW
3022 OP *lastop = 0;
3023 for (curop = LINKLIST(repl); curop!=repl; curop = LINKLIST(curop)) {
22c35a8c 3024 if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
554b3eca 3025#ifdef USE_THREADS
ce862d02
IZ
3026 if (curop->op_type == OP_THREADSV) {
3027 repl_has_vars = 1;
be949f6f 3028 if (strchr("&`'123456789+", curop->op_private))
ce862d02 3029 break;
554b3eca
MB
3030 }
3031#else
79072805 3032 if (curop->op_type == OP_GV) {
638eceb6 3033 GV *gv = cGVOPx_gv(curop);
ce862d02 3034 repl_has_vars = 1;
93a17b20 3035 if (strchr("&`'123456789+", *GvENAME(gv)))
79072805
LW
3036 break;
3037 }
554b3eca 3038#endif /* USE_THREADS */
79072805
LW
3039 else if (curop->op_type == OP_RV2CV)
3040 break;
3041 else if (curop->op_type == OP_RV2SV ||
3042 curop->op_type == OP_RV2AV ||
3043 curop->op_type == OP_RV2HV ||
3044 curop->op_type == OP_RV2GV) {
3045 if (lastop && lastop->op_type != OP_GV) /*funny deref?*/
3046 break;
3047 }
748a9306
LW
3048 else if (curop->op_type == OP_PADSV ||
3049 curop->op_type == OP_PADAV ||
3050 curop->op_type == OP_PADHV ||
554b3eca 3051 curop->op_type == OP_PADANY) {
ce862d02 3052 repl_has_vars = 1;
748a9306 3053 }
1167e5da
SM
3054 else if (curop->op_type == OP_PUSHRE)
3055 ; /* Okay here, dangerous in newASSIGNOP */
79072805
LW
3056 else
3057 break;
3058 }
3059 lastop = curop;
3060 }
748a9306 3061 }
ce862d02 3062 if (curop == repl
1c846c1f
NIS
3063 && !(repl_has_vars
3064 && (!pm->op_pmregexp
ce862d02 3065 || pm->op_pmregexp->reganch & ROPT_EVAL_SEEN))) {
748a9306 3066 pm->op_pmflags |= PMf_CONST; /* const for long enough */
4633a7c4 3067 pm->op_pmpermflags |= PMf_CONST; /* const for long enough */
11343788 3068 prepend_elem(o->op_type, scalar(repl), o);
748a9306
LW
3069 }
3070 else {
ce862d02
IZ
3071 if (curop == repl && !pm->op_pmregexp) { /* Has variables. */
3072 pm->op_pmflags |= PMf_MAYBE_CONST;
3073 pm->op_pmpermflags |= PMf_MAYBE_CONST;
3074 }
b7dc083c 3075 NewOp(1101, rcop, 1, LOGOP);
748a9306 3076 rcop->op_type = OP_SUBSTCONT;
22c35a8c 3077 rcop->op_ppaddr = PL_ppaddr[OP_SUBSTCONT];
748a9306
LW
3078 rcop->op_first = scalar(repl);
3079 rcop->op_flags |= OPf_KIDS;
3080 rcop->op_private = 1;
11343788 3081 rcop->op_other = o;
748a9306
LW
3082
3083 /* establish postfix order */
3084 rcop->op_next = LINKLIST(repl);
3085 repl->op_next = (OP*)rcop;
3086
3087 pm->op_pmreplroot = scalar((OP*)rcop);
3088 pm->op_pmreplstart = LINKLIST(rcop);
3089 rcop->op_next = 0;
79072805
LW
3090 }
3091 }
3092
3093 return (OP*)pm;
3094}
3095
3096OP *
864dbfa3 3097Perl_newSVOP(pTHX_ I32 type, I32 flags, SV *sv)
79072805
LW
3098{
3099 SVOP *svop;
b7dc083c 3100 NewOp(1101, svop, 1, SVOP);
79072805 3101 svop->op_type = type;
22c35a8c 3102 svop->op_ppaddr = PL_ppaddr[type];
79072805
LW
3103 svop->op_sv = sv;
3104 svop->op_next = (OP*)svop;
3105 svop->op_flags = flags;
22c35a8c 3106 if (PL_opargs[type] & OA_RETSCALAR)
463ee0b2 3107 scalar((OP*)svop);
22c35a8c 3108 if (PL_opargs[type] & OA_TARGET)
ed6116ce 3109 svop->op_targ = pad_alloc(type, SVs_PADTMP);
e50aee73 3110 return CHECKOP(type, svop);
79072805
LW
3111}
3112
3113OP *
350de78d
GS
3114Perl_newPADOP(pTHX_ I32 type, I32 flags, SV *sv)
3115{
3116 PADOP *padop;
3117 NewOp(1101, padop, 1, PADOP);
3118 padop->op_type = type;
3119 padop->op_ppaddr = PL_ppaddr[type];
3120 padop->op_padix = pad_alloc(type, SVs_PADTMP);
7766f137 3121 SvREFCNT_dec(PL_curpad[padop->op_padix]);
350de78d 3122 PL_curpad[padop->op_padix] = sv;
7766f137 3123 SvPADTMP_on(sv);
350de78d
GS
3124 padop->op_next = (OP*)padop;
3125 padop->op_flags = flags;
3126 if (PL_opargs[type] & OA_RETSCALAR)
3127 scalar((OP*)padop);
3128 if (PL_opargs[type] & OA_TARGET)
3129 padop->op_targ = pad_alloc(type, SVs_PADTMP);
3130 return CHECKOP(type, padop);
3131}
3132
3133OP *
864dbfa3 3134Perl_newGVOP(pTHX_ I32 type, I32 flags, GV *gv)
79072805 3135{
350de78d 3136#ifdef USE_ITHREADS
743e66e6 3137 GvIN_PAD_on(gv);
350de78d
GS
3138 return newPADOP(type, flags, SvREFCNT_inc(gv));
3139#else
7934575e 3140 return newSVOP(type, flags, SvREFCNT_inc(gv));
350de78d 3141#endif
79072805
LW
3142}
3143
3144OP *
864dbfa3 3145Perl_newPVOP(pTHX_ I32 type, I32 flags, char *pv)
79072805
LW
3146{
3147 PVOP *pvop;
b7dc083c 3148 NewOp(1101, pvop, 1, PVOP);
79072805 3149 pvop->op_type = type;
22c35a8c 3150 pvop->op_ppaddr = PL_ppaddr[type];
79072805
LW
3151 pvop->op_pv = pv;
3152 pvop->op_next = (OP*)pvop;
3153 pvop->op_flags = flags;
22c35a8c 3154 if (PL_opargs[type] & OA_RETSCALAR)
463ee0b2 3155 scalar((OP*)pvop);
22c35a8c 3156 if (PL_opargs[type] & OA_TARGET)
ed6116ce 3157 pvop->op_targ = pad_alloc(type, SVs_PADTMP);
e50aee73 3158 return CHECKOP(type, pvop);
79072805
LW
3159}
3160
79072805 3161void
864dbfa3 3162Perl_package(pTHX_ OP *o)
79072805 3163{
93a17b20 3164 SV *sv;
79072805 3165
3280af22
NIS
3166 save_hptr(&PL_curstash);
3167 save_item(PL_curstname);
11343788 3168 if (o) {
463ee0b2
LW
3169 STRLEN len;
3170 char *name;
11343788 3171 sv = cSVOPo->op_sv;
463ee0b2 3172 name = SvPV(sv, len);
3280af22
NIS
3173 PL_curstash = gv_stashpvn(name,len,TRUE);
3174 sv_setpvn(PL_curstname, name, len);
11343788 3175 op_free(o);
93a17b20
LW
3176 }
3177 else {
3280af22
NIS
3178 sv_setpv(PL_curstname,"<none>");
3179 PL_curstash = Nullhv;
93a17b20 3180 }
7ad382f4 3181 PL_hints |= HINT_BLOCK_SCOPE;
3280af22
NIS
3182 PL_copline = NOLINE;
3183 PL_expect = XSTATE;
79072805
LW
3184}
3185
85e6fe83 3186void
864dbfa3 3187Perl_utilize(pTHX_ int aver, I32 floor, OP *version, OP *id, OP *arg)
85e6fe83 3188{
a0d0e21e 3189 OP *pack;
a0d0e21e
LW
3190 OP *rqop;
3191 OP *imop;
b1cb66bf 3192 OP *veop;
78ca652e 3193 GV *gv;
85e6fe83 3194
a0d0e21e 3195 if (id->op_type != OP_CONST)
cea2e8a9 3196 Perl_croak(aTHX_ "Module name must be constant");
85e6fe83 3197
b1cb66bf
PP
3198 veop = Nullop;
3199
0f79a09d 3200 if (version != Nullop) {
b1cb66bf
PP
3201 SV *vesv = ((SVOP*)version)->op_sv;
3202
44dcb63b 3203 if (arg == Nullop && !SvNIOKp(vesv)) {
b1cb66bf
PP
3204 arg = version;
3205 }
3206 else {
3207 OP *pack;
0f79a09d 3208 SV *meth;
b1cb66bf 3209
44dcb63b 3210 if (version->op_type != OP_CONST || !SvNIOKp(vesv))
cea2e8a9 3211 Perl_croak(aTHX_ "Version number must be constant number");
b1cb66bf
PP
3212
3213 /* Make copy of id so we don't free it twice */
3214 pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv));
3215
3216 /* Fake up a method call to VERSION */
0f79a09d
GS
3217 meth = newSVpvn("VERSION",7);
3218 sv_upgrade(meth, SVt_PVIV);
155aba94 3219 (void)SvIOK_on(meth);
0f79a09d 3220 PERL_HASH(SvUVX(meth), SvPVX(meth), SvCUR(meth));
b1cb66bf
PP
3221 veop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
3222 append_elem(OP_LIST,
0f79a09d
GS
3223 prepend_elem(OP_LIST, pack, list(version)),
3224 newSVOP(OP_METHOD_NAMED, 0, meth)));
b1cb66bf
PP
3225 }
3226 }
aeea060c 3227
a0d0e21e 3228 /* Fake up an import/unimport */
4633a7c4
LW
3229 if (arg && arg->op_type == OP_STUB)
3230 imop = arg; /* no import on explicit () */
44dcb63b 3231 else if (SvNIOKp(((SVOP*)id)->op_sv)) {
b1cb66bf
PP
3232 imop = Nullop; /* use 5.0; */
3233 }
4633a7c4 3234 else {
0f79a09d
GS
3235 SV *meth;
3236
4633a7c4
LW
3237 /* Make copy of id so we don't free it twice */
3238 pack = newSVOP(OP_CONST, 0, newSVsv(((SVOP*)id)->op_sv));
0f79a09d
GS
3239
3240 /* Fake up a method call to import/unimport */
3241 meth = aver ? newSVpvn("import",6) : newSVpvn("unimport", 8);;
3242 sv_upgrade(meth, SVt_PVIV);
155aba94 3243 (void)SvIOK_on(meth);
0f79a09d 3244 PERL_HASH(SvUVX(meth), SvPVX(meth), SvCUR(meth));
4633a7c4 3245 imop = convert(OP_ENTERSUB, OPf_STACKED|OPf_SPECIAL,
0f79a09d
GS
3246 append_elem(OP_LIST,
3247 prepend_elem(OP_LIST, pack, list(arg)),
3248 newSVOP(OP_METHOD_NAMED, 0, meth)));
4633a7c4
LW
3249 }
3250
78ca652e
GS
3251 /* Fake up a require, handle override, if any */
3252 gv = gv_fetchpv("require", FALSE, SVt_PVCV);
3253 if (!(gv && GvIMPORTED_CV(gv)))
3254 gv = gv_fetchpv("CORE::GLOBAL::require", FALSE, SVt_PVCV);
3255
3256 if (gv && GvIMPORTED_CV(gv)) {
3257 rqop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
3258 append_elem(OP_LIST, id,
3259 scalar(newUNOP(OP_RV2CV, 0,
3260 newGVOP(OP_GV, 0,
3261 gv))))));
3262 }
3263 else {
3264 rqop = newUNOP(OP_REQUIRE, 0, id);
3265 }
a0d0e21e
LW
3266
3267 /* Fake up the BEGIN {}, which does its thing immediately. */
09bef843 3268 newATTRSUB(floor,
79cb57f6 3269 newSVOP(OP_CONST, 0, newSVpvn("BEGIN", 5)),
4633a7c4 3270 Nullop,
09bef843 3271 Nullop,
a0d0e21e 3272 append_elem(OP_LINESEQ,
b1cb66bf
PP
3273 append_elem(OP_LINESEQ,
3274 newSTATEOP(0, Nullch, rqop),
3275 newSTATEOP(0, Nullch, veop)),
a0d0e21e 3276 newSTATEOP(0, Nullch, imop) ));
85e6fe83 3277
c305c6a0 3278 PL_hints |= HINT_BLOCK_SCOPE;
3280af22
NIS
3279 PL_copline = NOLINE;
3280 PL_expect = XSTATE;
85e6fe83
LW
3281}
3282
e4783991
GS
3283void
3284Perl_load_module(pTHX_ U32 flags, SV *name, SV *ver, ...)
3285{
3286 va_list args;
3287 va_start(args, ver);
3288 vload_module(flags, name, ver, &args);
3289 va_end(args);
3290}
3291
3292#ifdef PERL_IMPLICIT_CONTEXT
3293void
3294Perl_load_module_nocontext(U32 flags, SV *name, SV *ver, ...)
3295{
3296 dTHX;
3297 va_list args;
3298 va_start(args, ver);
3299 vload_module(flags, name, ver, &args);
3300 va_end(args);
3301}
3302#endif
3303
3304void
3305Perl_vload_module(pTHX_ U32 flags, SV *name, SV *ver, va_list *args)
3306{
3307 OP *modname, *veop, *imop;
3308
3309 modname = newSVOP(OP_CONST, 0, name);
3310 modname->op_private |= OPpCONST_BARE;
3311 if (ver) {
3312 veop = newSVOP(OP_CONST, 0, ver);
3313 }
3314 else
3315 veop = Nullop;
3316 if (flags & PERL_LOADMOD_NOIMPORT) {
3317 imop = sawparens(newNULLLIST());
3318 }
3319 else if (flags & PERL_LOADMOD_IMPORT_OPS) {
3320 imop = va_arg(*args, OP*);
3321 }
3322 else {
3323 SV *sv;
3324 imop = Nullop;
3325 sv = va_arg(*args, SV*);
3326 while (sv) {
3327 imop = append_elem(OP_LIST, imop, newSVOP(OP_CONST, 0, sv));
3328 sv = va_arg(*args, SV*);
3329 }
3330 }
81885997
GS
3331 {
3332 line_t ocopline = PL_copline;
3333 int oexpect = PL_expect;
3334
3335 utilize(!(flags & PERL_LOADMOD_DENY), start_subparse(FALSE, 0),
3336 veop, modname, imop);
3337 PL_expect = oexpect;
3338 PL_copline = ocopline;
3339 }
e4783991
GS
3340}
3341
79072805 3342OP *
864dbfa3 3343Perl_dofile(pTHX_ OP *term)
78ca652e
GS
3344{
3345 OP *doop;
3346 GV *gv;
3347
3348 gv = gv_fetchpv("do", FALSE, SVt_PVCV);
3349 if (!(gv && GvIMPORTED_CV(gv)))
3350 gv = gv_fetchpv("CORE::GLOBAL::do", FALSE, SVt_PVCV);
3351
3352 if (gv && GvIMPORTED_CV(gv)) {
3353 doop = ck_subr(newUNOP(OP_ENTERSUB, OPf_STACKED,
3354 append_elem(OP_LIST, term,
3355 scalar(newUNOP(OP_RV2CV, 0,
3356 newGVOP(OP_GV, 0,
3357 gv))))));
3358 }
3359 else {
3360 doop = newUNOP(OP_DOFILE, 0, scalar(term));
3361 }
3362 return doop;
3363}
3364
3365OP *
864dbfa3 3366Perl_newSLICEOP(pTHX_ I32 flags, OP *subscript, OP *listval)
79072805
LW
3367{
3368 return newBINOP(OP_LSLICE, flags,
8990e307
LW
3369 list(force_list(subscript)),
3370 list(force_list(listval)) );
79072805
LW
3371}
3372
76e3520e 3373STATIC I32
cea2e8a9 3374S_list_assignment(pTHX_ register OP *o)
79072805 3375{
11343788 3376 if (!o)
79072805
LW
3377 return TRUE;
3378
11343788
MB
3379 if (o->op_type == OP_NULL && o->op_flags & OPf_KIDS)
3380 o = cUNOPo->op_first;
79072805 3381
11343788 3382 if (o->op_type == OP_COND_EXPR) {
1a67a97c
SM
3383 I32 t = list_assignment(cLOGOPo->op_first->op_sibling);
3384 I32 f = list_assignment(cLOGOPo->op_first->op_sibling->op_sibling);
79072805
LW
3385
3386 if (t && f)
3387 return TRUE;
3388 if (t || f)
3389 yyerror("Assignment to both a list and a scalar");
3390 return FALSE;
3391 }
3392
11343788
MB
3393 if (o->op_type == OP_LIST || o->op_flags & OPf_PARENS ||
3394 o->op_type == OP_RV2AV || o->op_type == OP_RV2HV ||
3395 o->op_type == OP_ASLICE || o->op_type == OP_HSLICE)
79072805
LW
3396 return TRUE;
3397
11343788 3398 if (o->op_type == OP_PADAV || o->op_type == OP_PADHV)
93a17b20
LW
3399 return TRUE;
3400
11343788 3401 if (o->op_type == OP_RV2SV)
79072805
LW
3402 return FALSE;
3403
3404 return FALSE;
3405}
3406
3407OP *
864dbfa3 3408Perl_newASSIGNOP(pTHX_ I32 flags, OP *left, I32 optype, OP *right)
79072805 3409{
11343788 3410 OP *o;
79072805 3411
a0d0e21e
LW
3412 if (optype) {
3413 if (optype == OP_ANDASSIGN || optype == OP_ORASSIGN) {
3414 return newLOGOP(optype, 0,
3415 mod(scalar(left), optype),
3416 newUNOP(OP_SASSIGN, 0, scalar(right)));
3417 }
3418 else {
3419 return newBINOP(optype, OPf_STACKED,
3420 mod(scalar(left), optype), scalar(right));
3421 }
3422 }
3423
79072805 3424 if (list_assignment(left)) {
10c8fecd
GS
3425 OP *curop;
3426
3280af22
NIS
3427 PL_modcount = 0;
3428 PL_eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/
463ee0b2 3429 left = mod(left, OP_AASSIGN);
3280af22
NIS
3430 if (PL_eval_start)
3431 PL_eval_start = 0;
748a9306 3432 else {
a0d0e21e
LW
3433 op_free(left);
3434 op_free(right);
3435 return Nullop;
3436 }
10c8fecd
GS
3437 curop = list(force_list(left));
3438 o = newBINOP(OP_AASSIGN, flags, list(force_list(right)), curop);
11343788 3439 o->op_private = 0 | (flags >> 8);
10c8fecd
GS
3440 for (curop = ((LISTOP*)curop)->op_first;
3441 curop; curop = curop->op_sibling)
3442 {
3443 if (curop->op_type == OP_RV2HV &&
3444 ((UNOP*)curop)->op_first->op_type != OP_GV) {
3445 o->op_private |= OPpASSIGN_HASH;
3446 break;
3447 }
3448 }
a0d0e21e 3449 if (!(left->op_private & OPpLVAL_INTRO)) {
11343788 3450 OP *lastop = o;
3280af22 3451 PL_generation++;
11343788 3452 for (curop = LINKLIST(o); curop != o; curop = LINKLIST(curop)) {
22c35a8c 3453 if (PL_opargs[curop->op_type] & OA_DANGEROUS) {
79072805 3454 if (curop->op_type == OP_GV) {
638eceb6 3455 GV *gv = cGVOPx_gv(curop);
3280af22 3456 if (gv == PL_defgv || SvCUR(gv) == PL_generation)
79072805 3457 break;
3280af22 3458 SvCUR(gv) = PL_generation;
79072805 3459 }
748a9306
LW
3460 else if (curop->op_type == OP_PADSV ||
3461 curop->op_type == OP_PADAV ||
3462 curop->op_type == OP_PADHV ||
3463 curop->op_type == OP_PADANY) {
3280af22 3464 SV **svp = AvARRAY(PL_comppad_name);
8e07c86e 3465 SV *sv = svp[curop->op_targ];
3280af22 3466 if (SvCUR(sv) == PL_generation)
748a9306 3467 break;
3280af22 3468 SvCUR(sv) = PL_generation; /* (SvCUR not used any more) */
748a9306 3469 }
79072805
LW
3470 else if (curop->op_type == OP_RV2CV)
3471 break;
3472 else if (curop->op_type == OP_RV2SV ||
3473 curop->op_type == OP_RV2AV ||
3474 curop->op_type == OP_RV2HV ||
3475 curop->op_type == OP_RV2GV) {
3476 if (lastop->op_type != OP_GV) /* funny deref? */
3477 break;
3478 }
1167e5da
SM
3479 else if (curop->op_type == OP_PUSHRE) {
3480 if (((PMOP*)curop)->op_pmreplroot) {
b3f5893f
GS
3481#ifdef USE_ITHREADS
3482 GV *gv = (GV*)PL_curpad[(PADOFFSET)((PMOP*)curop)->op_pmreplroot];
3483#else
1167e5da 3484 GV *gv = (GV*)((PMOP*)curop)->op_pmreplroot;
b3f5893f 3485#endif
3280af22 3486 if (gv == PL_defgv || SvCUR(gv) == PL_generation)
1167e5da 3487 break;
3280af22 3488 SvCUR(gv) = PL_generation;
1167e5da
SM
3489 }
3490 }
79072805
LW
3491 else
3492 break;
3493 }
3494 lastop = curop;
3495 }
11343788 3496 if (curop != o)
10c8fecd 3497 o->op_private |= OPpASSIGN_COMMON;
79072805 3498 }
c07a80fd
PP
3499 if (right && right->op_type == OP_SPLIT) {
3500 OP* tmpop;
3501 if ((tmpop = ((LISTOP*)right)->op_first) &&
3502 tmpop->op_type == OP_PUSHRE)
3503 {
3504 PMOP *pm = (PMOP*)tmpop;
3505 if (left->op_type == OP_RV2AV &&
3506 !(left->op_private & OPpLVAL_INTRO) &&
11343788 3507 !(o->op_private & OPpASSIGN_COMMON) )
c07a80fd
PP
3508 {
3509 tmpop = ((UNOP*)left)->op_first;
3510 if (tmpop->op_type == OP_GV && !pm->op_pmreplroot) {
971a9dd3
GS
3511#ifdef USE_ITHREADS
3512 pm->op_pmreplroot = (OP*)cPADOPx(tmpop)->op_padix;
3513 cPADOPx(tmpop)->op_padix = 0; /* steal it */
3514#else
3515 pm->op_pmreplroot = (OP*)cSVOPx(tmpop)->op_sv;
3516 cSVOPx(tmpop)->op_sv = Nullsv; /* steal it */
3517#endif
c07a80fd 3518 pm->op_pmflags |= PMf_ONCE;
11343788 3519 tmpop = cUNOPo->op_first; /* to list (nulled) */
c07a80fd
PP
3520 tmpop = ((UNOP*)tmpop)->op_first; /* to pushmark */
3521 tmpop->op_sibling = Nullop; /* don't free split */
3522 right->op_next = tmpop->op_next; /* fix starting loc */
11343788 3523 op_free(o); /* blow off assign */
54310121 3524 right->op_flags &= ~OPf_WANT;
a5f75d66 3525 /* "I don't know and I don't care." */
c07a80fd
PP
3526 return right;
3527 }
3528 }
3529 else {
e6438c1a 3530 if (PL_modcount < RETURN_UNLIMITED_NUMBER &&
c07a80fd
PP
3531 ((LISTOP*)right)->op_last->op_type == OP_CONST)
3532 {
3533 SV *sv = ((SVOP*)((LISTOP*)right)->op_last)->op_sv;
3534 if (SvIVX(sv) == 0)
3280af22 3535 sv_setiv(sv, PL_modcount+1);
c07a80fd
PP
3536 }
3537 }
3538 }
3539 }
11343788 3540 return o;
79072805
LW
3541 }
3542 if (!right)
3543 right = newOP(OP_UNDEF, 0);
3544 if (right->op_type == OP_READLINE) {
3545 right->op_flags |= OPf_STACKED;
463ee0b2 3546 return newBINOP(OP_NULL, flags, mod(scalar(left), OP_SASSIGN), scalar(right));
79072805 3547 }
a0d0e21e 3548 else {
3280af22 3549 PL_eval_start = right; /* Grandfathering $[ assignment here. Bletch.*/